@voxgig/sdkgen 1.3.8 → 1.3.9

package/project/.sdk/tm/zig/core/context.zig

@@ -0,0 +1,258 @@
+// Operation context (mirrors go core/context.go / rust core/context.rs).
+// Contexts are heap-allocated (*Context) and mutated in place through the
+// pointer — Zig needs no RefCell, and the Value fields are already
+// reference-stable via *MapRef / *ListRef.
+
+const std = @import("std");
+const h = @import("helpers.zig");
+const err = @import("error.zig");
+const control_mod = @import("control.zig");
+const operation_mod = @import("operation.zig");
+const spec_mod = @import("spec.zig");
+const response_mod = @import("response.zig");
+const result_mod = @import("result.zig");
+const types = @import("types.zig");
+const utility_mod = @import("utility.zig");
+const sdk = @import("sdk.zig");
+
+const Value = h.Value;
+const Control = control_mod.Control;
+const Operation = operation_mod.Operation;
+const Spec = spec_mod.Spec;
+const Response = response_mod.Response;
+const SdkResult = result_mod.SdkResult;
+const Entity = types.Entity;
+const OutVal = types.OutVal;
+const Utility = utility_mod.Utility;
+const SdkError = err.ProjectNameError;
+
+pub const OpMap = std.StringHashMap(*Operation);
+
+// Construction spec for a Context.
+pub const CtxSpec = struct {
+    opname: ?[]const u8 = null,
+    client: ?*sdk.ProjectNameSDK = null,
+    utility: ?*Utility = null,
+    ctrl: ?Value = null,
+    ctrl_obj: ?*Control = null,
+    meta: ?Value = null,
+    config: ?Value = null,
+    entopts: ?Value = null,
+    options: ?Value = null,
+    entity: ?Entity = null,
+    shared: ?Value = null,
+    opmap: ?*OpMap = null,
+    data: ?Value = null,
+    reqdata: ?Value = null,
+    mtch: ?Value = null,
+    reqmatch: ?Value = null,
+    point: ?Value = null,
+    spec: ?*Spec = null,
+    result: ?*SdkResult = null,
+    response: ?*Response = null,
+};
+
+pub const Context = struct {
+    id: []const u8,
+    out: std.StringHashMap(OutVal),
+    ctrl: *Control,
+    meta: Value,
+    client: ?*sdk.ProjectNameSDK,
+    utility: ?*Utility,
+    op: *Operation,
+    point: Value,
+    config: Value,
+    entopts: Value,
+    options: Value,
+    opmap: *OpMap,
+    response: ?*Response,
+    result: ?*SdkResult,
+    spec: ?*Spec,
+    data: Value,
+    reqdata: Value,
+    mtch: Value,
+    reqmatch: Value,
+    entity: ?Entity,
+    shared: Value,
+    pending_err: ?*SdkError = null,
+
+    fn mapOrEmpty(v: ?Value) Value {
+        if (v) |val| {
+            if (h.to_map(val) == .object) return val;
+        }
+        return h.omap();
+    }
+
+    pub fn new(ctxspec: CtxSpec, basectx: ?*Context) *Context {
+        const id = std.fmt.allocPrint(h.A(), "C{d}", .{h.rand_int(90000000) + 10000000}) catch "C0";
+
+        const client = ctxspec.client orelse (if (basectx) |b| b.client else null);
+        const utility = ctxspec.utility orelse (if (basectx) |b| b.utility else null);
+
+        // Ctrl
+        var ctrl: *Control = undefined;
+        if (ctxspec.ctrl) |cm| {
+            const c = Control.make();
+            if (h.get_bool(cm, "throw")) |t| c.throw = t;
+            if (h.getp(cm, "explain") == .object) c.explain = h.getp(cm, "explain");
+            if (h.get_str(cm, "actor")) |a| c.actor = a;
+            if (h.getp(cm, "paging") == .object) c.paging = h.getp(cm, "paging");
+            ctrl = c;
+        } else if (ctxspec.ctrl_obj) |co| {
+            ctrl = co;
+        } else if (basectx) |b| {
+            ctrl = b.ctrl;
+        } else {
+            ctrl = Control.make();
+        }
+
+        // Meta
+        const meta: Value = ctxspec.meta orelse blk: {
+            if (basectx) |b| {
+                if (b.meta == .object) break :blk b.meta;
+            }
+            break :blk h.omap();
+        };
+
+        // Config / Entopts / Options / Entity / Shared: fall back to base.
+        const config: Value = ctxspec.config orelse (if (basectx) |b| b.config else h.vnull());
+        const entopts: Value = ctxspec.entopts orelse (if (basectx) |b| b.entopts else h.vnull());
+        const options: Value = ctxspec.options orelse (if (basectx) |b| b.options else h.vnull());
+        const entity: ?Entity = ctxspec.entity orelse (if (basectx) |b| b.entity else null);
+        const shared: Value = ctxspec.shared orelse blk: {
+            if (basectx) |b| {
+                if (b.shared == .object) break :blk b.shared;
+            }
+            break :blk h.vnull();
+        };
+
+        // Opmap (shared with the base context).
+        const opmap: *OpMap = ctxspec.opmap orelse (if (basectx) |b| b.opmap else blk: {
+            const m = h.A().create(OpMap) catch unreachable;
+            m.* = OpMap.init(h.A());
+            break :blk m;
+        });
+
+        // Data maps (never inherited).
+        const data = mapOrEmpty(ctxspec.data);
+        const reqdata = mapOrEmpty(ctxspec.reqdata);
+        const mtch = mapOrEmpty(ctxspec.mtch);
+        const reqmatch = mapOrEmpty(ctxspec.reqmatch);
+
+        // Point / Spec / Result / Response: fall back to base.
+        const point: Value = ctxspec.point orelse blk: {
+            if (basectx) |b| {
+                if (b.point == .object) break :blk b.point;
+            }
+            break :blk h.vnull();
+        };
+        const spec: ?*Spec = ctxspec.spec orelse (if (basectx) |b| b.spec else null);
+        const result: ?*SdkResult = ctxspec.result orelse (if (basectx) |b| b.result else null);
+        const response: ?*Response = ctxspec.response orelse (if (basectx) |b| b.response else null);
+
+        const ctx = h.A().create(Context) catch unreachable;
+        ctx.* = .{
+            .id = id,
+            .out = std.StringHashMap(OutVal).init(h.A()),
+            .ctrl = ctrl,
+            .meta = meta,
+            .client = client,
+            .utility = utility,
+            .op = Operation.make(h.omap()),
+            .point = point,
+            .config = config,
+            .entopts = entopts,
+            .options = options,
+            .opmap = opmap,
+            .response = response,
+            .result = result,
+            .spec = spec,
+            .data = data,
+            .reqdata = reqdata,
+            .mtch = mtch,
+            .reqmatch = reqmatch,
+            .entity = entity,
+            .shared = shared,
+            .pending_err = null,
+        };
+
+        const opname = ctxspec.opname orelse "";
+        ctx.op = ctx.resolve_op(opname);
+
+        return ctx;
+    }
+
+    fn resolve_op(self: *Context, opname: []const u8) *Operation {
+        const entname: []const u8 = if (self.entity) |e| e.get_name() else "";
+        const cache_key = std.fmt.allocPrint(h.A(), "{s}:{s}", .{ entname, opname }) catch opname;
+
+        if (self.opmap.get(cache_key)) |op| return op;
+
+        if (opname.len == 0) {
+            return Operation.make(h.omap());
+        }
+
+        const opcfg = h.getpath(&.{ "entity", entname, "op", opname }, self.config);
+
+        const input: []const u8 = if (std.mem.eql(u8, opname, "update") or std.mem.eql(u8, opname, "create")) "data" else "match";
+
+        const targets: Value = switch (h.getp(opcfg, "points")) {
+            .array => h.getp(opcfg, "points"),
+            else => h.olist(),
+        };
+
+        const op = Operation.make(h.jo(&.{
+            .{ "entity", h.vstr(entname) },
+            .{ "name", h.vstr(opname) },
+            .{ "input", h.vstr(input) },
+            .{ "points", targets },
+        }));
+
+        self.opmap.put(cache_key, op) catch {};
+        return op;
+    }
+
+    pub fn make_error(self: *Context, code: []const u8, msg: []const u8) *SdkError {
+        _ = self;
+        return SdkError.make(code, msg);
+    }
+
+    // Stash a pending error and return the pipeline error sentinel.
+    pub fn fail(self: *Context, code: []const u8, msg: []const u8) err.E {
+        self.pending_err = SdkError.make(code, msg);
+        return error.Sdk;
+    }
+
+    pub fn fail_err(self: *Context, e: *SdkError) err.E {
+        self.pending_err = e;
+        return error.Sdk;
+    }
+
+    pub fn take_err(self: *Context) ?*SdkError {
+        const e = self.pending_err;
+        self.pending_err = null;
+        return e;
+    }
+
+    pub fn util(self: *Context) *Utility {
+        return self.utility orelse unreachable;
+    }
+
+    // --- ctx.out staging helpers ---
+
+    pub fn out_get(self: *Context, key: []const u8) ?OutVal {
+        return self.out.get(key);
+    }
+    pub fn out_set(self: *Context, key: []const u8, val: OutVal) void {
+        self.out.put(key, val) catch {};
+    }
+    pub fn out_val(self: *Context, key: []const u8) Value {
+        if (self.out.get(key)) |ov| {
+            switch (ov) {
+                .val => |v| return v,
+                else => {},
+            }
+        }
+        return h.vnull();
+    }
+};

package/project/.sdk/tm/zig/core/control.zig

@@ -0,0 +1,26 @@
+// Per-call control state (mirrors go core/control.go).
+
+const h = @import("helpers.zig");
+const err = @import("error.zig");
+const Value = h.Value;
+
+pub const Control = struct {
+    throw: ?bool = null,
+    err: ?*err.ProjectNameError = null,
+    // explain / paging are Value maps when supplied (.null otherwise). They
+    // are the caller's own maps (reference-shared), so recorded entries are
+    // visible to the caller after the operation completes.
+    explain: Value = .{ .null = {} },
+    actor: []const u8 = "",
+    paging: Value = .{ .null = {} },
+
+    pub fn make() *Control {
+        const c = h.A().create(Control) catch unreachable;
+        c.* = .{};
+        return c;
+    }
+
+    pub fn has_explain(self: *const Control) bool {
+        return self.explain == .object;
+    }
+};

package/project/.sdk/tm/zig/core/error.zig

@@ -0,0 +1,28 @@
+// ProjectNameError: the SDK error type (mirrors go core/error.go / the rust
+// SdkError fragment). The pipeline error discipline is `E!T` (E = error{Sdk})
+// with the rich error object stashed on the context's pending_err, then read
+// back by makeError. This templated file only needs the project name.
+
+const vs = @import("voxgig-struct");
+const mem = @import("mem.zig");
+const Value = vs.JsonValue;
+
+pub const ProjectNameError = struct {
+    sdk: []const u8 = "ProjectName",
+    code: []const u8,
+    msg: []const u8,
+    // Cleaned snapshots attached by makeError (null until then).
+    result: Value = .{ .null = {} },
+    spec: Value = .{ .null = {} },
+
+    // Heap-allocate a fresh error on the SDK arena (so it can be pointed at
+    // from ctx.pending_err / ctrl.err and outlive the call frame).
+    pub fn make(code: []const u8, msg: []const u8) *ProjectNameError {
+        const e = mem.a().create(ProjectNameError) catch unreachable;
+        e.* = .{ .sdk = "ProjectName", .code = code, .msg = msg };
+        return e;
+    }
+};
+
+// The pipeline error set. The payload travels via ctx.pending_err.
+pub const E = error{Sdk};

package/project/.sdk/tm/zig/core/helpers.zig

@@ -0,0 +1,326 @@
+// Shared Value helpers for the ProjectName SDK pipeline. The SDK data model
+// is the vendored voxgig struct `JsonValue` (utility/voxgigstruct) — the
+// JSON-shaped, reference-stable (*MapRef / *ListRef) node used for ctx data,
+// specs, options, transport payloads and results, exactly as the Go SDK
+// passes map[string]any around. `.null` doubles as "absent" (Group A rule),
+// so is_noval and is_null are the same test here.
+
+const std = @import("std");
+const vs = @import("voxgig-struct");
+const mem = @import("mem.zig");
+const err = @import("error.zig");
+
+pub const Value = vs.JsonValue;
+pub const Allocator = std.mem.Allocator;
+pub const SdkError = err.ProjectNameError;
+pub const E = err.E;
+
+pub fn A() Allocator {
+    return mem.a();
+}
+
+// ---- constructors ------------------------------------------------------
+
+pub fn vstr(s: []const u8) Value {
+    return .{ .string = s };
+}
+pub fn vnum(n: i64) Value {
+    return .{ .integer = n };
+}
+pub fn vfloat(n: f64) Value {
+    return .{ .float = n };
+}
+pub fn vbool(b: bool) Value {
+    return .{ .bool = b };
+}
+pub fn vnull() Value {
+    return .{ .null = {} };
+}
+pub fn omap() Value {
+    return Value.makeMap(A()) catch unreachable;
+}
+pub fn olist() Value {
+    return Value.makeList(A()) catch unreachable;
+}
+
+// ---- predicates --------------------------------------------------------
+
+pub fn is_null(v: Value) bool {
+    return v == .null;
+}
+pub fn is_noval(v: Value) bool {
+    return v == .null;
+}
+pub fn ismap(v: Value) bool {
+    return v == .object;
+}
+pub fn islist(v: Value) bool {
+    return v == .array;
+}
+pub fn isfunc(v: Value) bool {
+    return v == .function;
+}
+
+// ---- struct wrappers (allocator-first, error-swallowing) ---------------
+
+pub fn clone(v: Value) Value {
+    return vs.clone(A(), v) catch v;
+}
+pub fn sizeOf(v: Value) i64 {
+    return vs.size(v);
+}
+pub fn typify(v: Value) i64 {
+    return vs.typify(v);
+}
+pub fn is_empty(v: Value) bool {
+    return vs.isempty(v);
+}
+pub fn get_elem(v: Value, key: Value, alt: Value) Value {
+    return vs.getelem(A(), v, key, alt) catch alt;
+}
+pub fn esc_re(s: []const u8) []const u8 {
+    return vs.escre(A(), s) catch s;
+}
+pub fn esc_url(s: []const u8) []const u8 {
+    return vs.escurl(A(), s) catch s;
+}
+pub fn jsonify_compact(v: Value) []const u8 {
+    return vs.jsonifyCompact(A(), v) catch "";
+}
+pub fn merge(v: Value) Value {
+    return vs.merge(A(), v, vs.MAXDEPTH) catch v;
+}
+
+// JS String()-style scalar rendering for URL params / keys.
+pub fn scalar_str(v: Value) []const u8 {
+    return switch (v) {
+        .string => |s| s,
+        .integer => |i| std.fmt.allocPrint(A(), "{d}", .{i}) catch "",
+        .float => |f| std.fmt.allocPrint(A(), "{d}", .{f}) catch "",
+        .bool => |b| if (b) "true" else "false",
+        else => vs.stringify(A(), v, null) catch "",
+    };
+}
+
+pub fn stringify(v: Value) []const u8 {
+    return vs.stringify(A(), v, null) catch "";
+}
+
+// ---- property / path access --------------------------------------------
+
+// Property read: getp(map, "key") — .null when absent (mirrors GetProp).
+pub fn getp(val: Value, key: []const u8) Value {
+    return vs.getprop(A(), val, vstr(key), vnull()) catch vnull();
+}
+
+// Property write (no-op when val is not a map). Direct map put so an explicit
+// null value is stored (not treated as a delete), and the key is duped onto
+// the arena so temp-buffer keys stay valid.
+pub fn setp(val: Value, key: []const u8, newval: Value) void {
+    switch (val) {
+        .object => |m| {
+            const k = A().dupe(u8, key) catch key;
+            m.put(k, newval) catch {};
+        },
+        else => {},
+    }
+}
+
+// Path read on a Value store.
+pub fn getpath(path: []const []const u8, store: Value) Value {
+    const pl = Value.makeList(A()) catch unreachable;
+    for (path) |seg| pl.array.append(vstr(seg)) catch {};
+    return vs.getpath(A(), pl, store) catch vnull();
+}
+
+// Path write on a Value store. The store's *MapRef nodes are mutated in
+// place, so the caller keeps using the ROOT (never rebinds to the return —
+// gotcha #8). We discard the return here for exactly that reason.
+pub fn setpath(store: Value, path: []const []const u8, val: Value) void {
+    const pl = Value.makeList(A()) catch unreachable;
+    for (path) |seg| pl.array.append(vstr(seg)) catch {};
+    _ = vs.setpath(A(), store, pl, val) catch {};
+}
+
+pub fn del_prop(parent: Value, key: Value) void {
+    _ = vs.delprop(A(), parent, key) catch {};
+}
+
+// ---- literal builders --------------------------------------------------
+
+pub const Pair = struct { []const u8, Value };
+
+pub fn jo(pairs: []const Pair) Value {
+    const m = omap();
+    for (pairs) |p| setp(m, p[0], p[1]);
+    return m;
+}
+
+pub fn ja(vals: []const Value) Value {
+    const l = olist();
+    for (vals) |it| l.array.append(it) catch {};
+    return l;
+}
+
+// ---- coercions ---------------------------------------------------------
+
+pub fn to_map(v: Value) Value {
+    return if (v == .object) v else vnull();
+}
+
+pub fn to_int(v: Value) i64 {
+    return switch (v) {
+        .integer => |i| i,
+        .float => |f| @intFromFloat(f),
+        else => -1,
+    };
+}
+
+pub fn get_str(m: Value, key: []const u8) ?[]const u8 {
+    return switch (getp(m, key)) {
+        .string => |s| s,
+        else => null,
+    };
+}
+pub fn get_bool(m: Value, key: []const u8) ?bool {
+    return switch (getp(m, key)) {
+        .bool => |b| b,
+        else => null,
+    };
+}
+pub fn get_i64(m: Value, key: []const u8) ?i64 {
+    return switch (getp(m, key)) {
+        .integer => |i| i,
+        .float => |f| @intFromFloat(f),
+        else => null,
+    };
+}
+pub fn get_f64(m: Value, key: []const u8) ?f64 {
+    return switch (getp(m, key)) {
+        .integer => |i| @floatFromInt(i),
+        .float => |f| f,
+        else => null,
+    };
+}
+
+// ---- deep equality (mirrors the rust Value PartialEq) ------------------
+
+fn numOf(v: Value) ?f64 {
+    return switch (v) {
+        .integer => |i| @floatFromInt(i),
+        .float => |f| f,
+        else => null,
+    };
+}
+
+pub fn veq(x: Value, y: Value) bool {
+    if (numOf(x)) |xn| {
+        if (numOf(y)) |yn| return xn == yn;
+    }
+    return switch (x) {
+        .null => y == .null,
+        .bool => |b| y == .bool and y.bool == b,
+        .string => |s| y == .string and std.mem.eql(u8, s, y.string),
+        .number_string => |s| y == .number_string and std.mem.eql(u8, s, y.number_string),
+        .object => |m| blk: {
+            if (y != .object) break :blk false;
+            const n = y.object;
+            if (m.count() != n.count()) break :blk false;
+            var it = m.iterator();
+            while (it.next()) |kv| {
+                const ov = n.get(kv.key_ptr.*) orelse break :blk false;
+                if (!veq(kv.value_ptr.*, ov)) break :blk false;
+            }
+            break :blk true;
+        },
+        .array => |l| blk: {
+            if (y != .array) break :blk false;
+            const n = y.array;
+            if (l.data.items.len != n.data.items.len) break :blk false;
+            for (l.data.items, n.data.items) |a_, b_| {
+                if (!veq(a_, b_)) break :blk false;
+            }
+            break :blk true;
+        },
+        else => false,
+    };
+}
+
+// ---- key / item vectors (test feature convenience) ---------------------
+
+pub fn keysof_vec(v: Value) [][]const u8 {
+    var out = std.ArrayList([]const u8).init(A());
+    if (v == .object) {
+        var it = v.object.iterator();
+        while (it.next()) |kv| out.append(kv.key_ptr.*) catch {};
+    }
+    return out.toOwnedSlice() catch &.{};
+}
+
+pub const KVpair = struct { k: []const u8, v: Value };
+
+pub fn items_vec(v: Value) []KVpair {
+    var out = std.ArrayList(KVpair).init(A());
+    if (v == .object) {
+        var it = v.object.iterator();
+        while (it.next()) |kv| out.append(.{ .k = kv.key_ptr.*, .v = kv.value_ptr.* }) catch {};
+    }
+    return out.toOwnedSlice() catch &.{};
+}
+
+// ---- clocks / rng ------------------------------------------------------
+
+pub fn now_ms() i64 {
+    return std.time.milliTimestamp();
+}
+
+pub fn sleep_ms(ms: i64) void {
+    if (ms > 0) std.time.sleep(@as(u64, @intCast(ms)) * std.time.ns_per_ms);
+}
+
+var rand_seed: i64 = 123456789;
+
+pub fn rand_int(n: i64) i64 {
+    if (n <= 0) return 0;
+    rand_seed = (rand_seed *% 1103515245 +% 12345) & 0x7fffffff;
+    return @mod(rand_seed, n);
+}
+
+// ---- callables ---------------------------------------------------------
+
+pub const CallFn = *const fn (ctx: *anyopaque, allocator: Allocator, arg: Value) anyerror!Value;
+
+pub fn callable(ctx_ptr: *anyopaque, f: CallFn) Value {
+    const c = A().create(vs.Callable) catch unreachable;
+    c.* = .{ .ctx = ctx_ptr, .call = f };
+    return .{ .function = c };
+}
+
+pub fn call_vfn(f: Value, arg: Value) Value {
+    return switch (f) {
+        .function => |c| c.call(c.ctx, A(), arg) catch vnull(),
+        else => vnull(),
+    };
+}
+
+pub fn call_json(json: Value) Value {
+    return call_vfn(json, vnull());
+}
+
+const ThunkCtx = struct { data: Value };
+fn thunkCall(ctx: *anyopaque, _: Allocator, _: Value) anyerror!Value {
+    const tc: *ThunkCtx = @ptrCast(@alignCast(ctx));
+    return tc.data;
+}
+
+pub fn json_thunk(data: Value) Value {
+    const tc = A().create(ThunkCtx) catch unreachable;
+    tc.* = .{ .data = data };
+    return callable(@ptrCast(tc), thunkCall);
+}
+
+// UnsupportedOp error for entity ops the API spec doesn't define.
+pub fn unsupported_op(opname: []const u8, entityname: []const u8) *SdkError {
+    const msg = std.fmt.allocPrint(A(), "operation '{s}' not supported by entity '{s}'", .{ opname, entityname }) catch "unsupported op";
+    return SdkError.make("unsupported_op", msg);
+}

package/project/.sdk/tm/zig/core/mem.zig

@@ -0,0 +1,20 @@
+// Process-global arena allocator for the SDK data model.
+//
+// The SDK data model is the vendored voxgig struct Value (reference-stable
+// *MapRef / *ListRef nodes). Rust leans on a global allocator + Rc; Zig has
+// neither, so the whole SDK allocates from one process-lifetime arena. It is
+// never freed during a run — the OS reclaims at exit — which keeps the port
+// close to the Rust original and sidesteps the test allocator's leak checks
+// for SDK/struct data (tests still use testing.allocator for their own
+// bookkeeping). Mirrors struct/zig's per-run arena approach.
+
+const std = @import("std");
+
+var arena: ?std.heap.ArenaAllocator = null;
+
+pub fn a() std.mem.Allocator {
+    if (arena == null) {
+        arena = std.heap.ArenaAllocator.init(std.heap.page_allocator);
+    }
+    return arena.?.allocator();
+}

package/project/.sdk/tm/zig/core/operation.zig

@@ -0,0 +1,34 @@
+// Operation description (mirrors go core/operation.go).
+
+const h = @import("helpers.zig");
+const Value = h.Value;
+
+pub const Operation = struct {
+    entity: []const u8 = "_",
+    name: []const u8 = "_",
+    input: []const u8 = "_",
+    points: Value,
+    alias: Value,
+
+    pub fn make(opmap: Value) *Operation {
+        const o = h.A().create(Operation) catch unreachable;
+
+        const entity = h.get_str(opmap, "entity");
+        const name = h.get_str(opmap, "name");
+        const input = h.get_str(opmap, "input");
+
+        const points: Value = switch (h.getp(opmap, "points")) {
+            .array => h.getp(opmap, "points"),
+            else => h.olist(),
+        };
+
+        o.* = .{
+            .entity = if (entity) |e| (if (e.len == 0) "_" else e) else "_",
+            .name = if (name) |n| (if (n.len == 0) "_" else n) else "_",
+            .input = if (input) |i| (if (i.len == 0) "_" else i) else "_",
+            .points = points,
+            .alias = h.to_map(h.getp(opmap, "alias")),
+        };
+        return o;
+    }
+};