@ottochain/sdk 2.0.0 → 2.2.0

package/dist/types/apps/identity/state-machines/index.d.ts

@@ -1,596 +1,1098 @@
 /**
- * Auto-generated from JSON state machine definitions.
- * DO NOT EDIT - regenerate with: npm run prebuild
+ * Identity State Machine Definitions
+ *
+ * TypeScript-first definitions - no JSON, no code generation.
  */
-export declare const identityAgentDef: {
-    readonly metadata: {
-        readonly name: "IdentityAgent";
-        readonly description: "Standard agent identity with reputation tracking, vouching, and lifecycle management";
-        readonly version: "1.0.0";
-    };
-    readonly states: {
-        readonly REGISTERED: {
-            readonly id: "REGISTERED";
-            readonly isFinal: false;
-            readonly metadata: null;
+export { identityAgentDef, type AgentState, type AgentEvent, } from "./identity-agent.js";
+export { identityOracleDef, type OracleState, type OracleEvent, } from "./identity-oracle.js";
+export { identityUniversalDef, type UniversalIdentityState, type UniversalIdentityEvent, } from "./identity-universal.js";
+export declare const IDENTITY_DEFINITIONS: {
+    readonly agent: () => Promise<{
+        metadata: {
+            name: string;
+            app: string;
+            type: string;
+            version: string;
+            description: string;
         };
-        readonly ACTIVE: {
-            readonly id: "ACTIVE";
-            readonly isFinal: false;
-            readonly metadata: null;
-        };
-        readonly CHALLENGED: {
-            readonly id: "CHALLENGED";
-            readonly isFinal: false;
-            readonly metadata: null;
-        };
-        readonly SUSPENDED: {
-            readonly id: "SUSPENDED";
-            readonly isFinal: false;
-            readonly metadata: null;
-        };
-        readonly PROBATION: {
-            readonly id: "PROBATION";
-            readonly isFinal: false;
-            readonly metadata: null;
-        };
-        readonly WITHDRAWN: {
-            readonly id: "WITHDRAWN";
-            readonly isFinal: true;
-            readonly metadata: null;
-        };
-    };
-    readonly initialState: "REGISTERED";
-    readonly transitions: readonly [{
-        readonly from: "REGISTERED";
-        readonly to: "ACTIVE";
-        readonly eventName: "activate";
-        readonly guard: {
-            readonly "==": readonly [1, 1];
-        };
-        readonly effect: {
-            readonly merge: readonly [{
-                readonly var: "state";
-            }, {
-                readonly status: "ACTIVE";
-                readonly activatedAt: {
-                    readonly var: "$timestamp";
-                };
-            }];
-        };
-        readonly dependencies: readonly [];
-    }, {
-        readonly from: "ACTIVE";
-        readonly to: "ACTIVE";
-        readonly eventName: "receive_vouch";
-        readonly guard: {
-            readonly "!!": readonly [{
-                readonly var: "event.from";
-            }];
-        };
-        readonly effect: {
-            readonly merge: readonly [{
-                readonly var: "state";
-            }, {
-                readonly reputation: {
-                    readonly "+": readonly [{
-                        readonly var: "state.reputation";
-                    }, 2];
-                };
-            }];
-        };
-        readonly dependencies: readonly [];
-    }, {
-        readonly from: "ACTIVE";
-        readonly to: "ACTIVE";
-        readonly eventName: "receive_completion";
-        readonly guard: {
-            readonly "==": readonly [1, 1];
-        };
-        readonly effect: {
-            readonly merge: readonly [{
-                readonly var: "state";
-            }, {
-                readonly reputation: {
-                    readonly "+": readonly [{
-                        readonly var: "state.reputation";
-                    }, 5];
-                };
-            }];
-        };
-        readonly dependencies: readonly [];
-    }, {
-        readonly from: "ACTIVE";
-        readonly to: "CHALLENGED";
-        readonly eventName: "challenge";
-        readonly guard: {
-            readonly "!!": readonly [{
-                readonly var: "event.challenger";
-            }];
-        };
-        readonly effect: {
-            readonly merge: readonly [{
-                readonly var: "state";
-            }, {
-                readonly status: "CHALLENGED";
-                readonly challengedBy: {
-                    readonly var: "event.challenger";
-                };
-            }];
-        };
-        readonly dependencies: readonly [];
-    }, {
-        readonly from: "CHALLENGED";
-        readonly to: "ACTIVE";
-        readonly eventName: "dismiss_challenge";
-        readonly guard: {
-            readonly "==": readonly [1, 1];
-        };
-        readonly effect: {
-            readonly merge: readonly [{
-                readonly var: "state";
-            }, {
-                readonly status: "ACTIVE";
-                readonly challengedBy: null;
-            }];
-        };
-        readonly dependencies: readonly [];
-    }, {
-        readonly from: "CHALLENGED";
-        readonly to: "SUSPENDED";
-        readonly eventName: "uphold_challenge";
-        readonly guard: {
-            readonly "==": readonly [1, 1];
-        };
-        readonly effect: {
-            readonly merge: readonly [{
-                readonly var: "state";
-            }, {
-                readonly status: "SUSPENDED";
-                readonly suspendedAt: {
-                    readonly var: "$timestamp";
-                };
-            }];
-        };
-        readonly dependencies: readonly [];
-    }, {
-        readonly from: "SUSPENDED";
-        readonly to: "PROBATION";
-        readonly eventName: "begin_probation";
-        readonly guard: {
-            readonly "==": readonly [1, 1];
-        };
-        readonly effect: {
-            readonly merge: readonly [{
-                readonly var: "state";
-            }, {
-                readonly status: "PROBATION";
-                readonly probationStartedAt: {
-                    readonly var: "$timestamp";
-                };
-            }];
-        };
-        readonly dependencies: readonly [];
-    }, {
-        readonly from: "PROBATION";
-        readonly to: "ACTIVE";
-        readonly eventName: "complete_probation";
-        readonly guard: {
-            readonly "==": readonly [1, 1];
-        };
-        readonly effect: {
-            readonly merge: readonly [{
-                readonly var: "state";
-            }, {
-                readonly status: "ACTIVE";
-                readonly probationStartedAt: null;
-            }];
-        };
-        readonly dependencies: readonly [];
-    }, {
-        readonly from: "ACTIVE";
-        readonly to: "WITHDRAWN";
-        readonly eventName: "withdraw";
-        readonly guard: {
-            readonly "==": readonly [1, 1];
-        };
-        readonly effect: {
-            readonly merge: readonly [{
-                readonly var: "state";
-            }, {
-                readonly status: "WITHDRAWN";
-            }];
-        };
-        readonly dependencies: readonly [];
-    }];
-};
-export declare const identityOracleDef: {
-    readonly metadata: {
-        readonly name: "IdentityOracle";
-        readonly description: "Oracle identity with staking, attestations, reputation, and slashing mechanics";
-        readonly version: "1.0.0";
-    };
-    readonly states: {
-        readonly UNREGISTERED: {
-            readonly id: "UNREGISTERED";
-            readonly isFinal: false;
-            readonly metadata: null;
-        };
-        readonly REGISTERED: {
-            readonly id: "REGISTERED";
-            readonly isFinal: false;
-            readonly metadata: null;
-        };
-        readonly ACTIVE: {
-            readonly id: "ACTIVE";
-            readonly isFinal: false;
-            readonly metadata: null;
-        };
-        readonly SLASHED: {
-            readonly id: "SLASHED";
-            readonly isFinal: false;
-            readonly metadata: null;
-        };
-        readonly WITHDRAWN: {
-            readonly id: "WITHDRAWN";
-            readonly isFinal: true;
-            readonly metadata: null;
-        };
-    };
-    readonly initialState: "UNREGISTERED";
-    readonly transitions: readonly [{
-        readonly from: "UNREGISTERED";
-        readonly to: "REGISTERED";
-        readonly eventName: "register";
-        readonly guard: {
-            readonly ">=": readonly [{
-                readonly var: "event.stake";
-            }, {
-                readonly var: "state.minStake";
-            }];
-        };
-        readonly effect: {
-            readonly merge: readonly [{
-                readonly var: "state";
-            }, {
-                readonly status: "REGISTERED";
-                readonly address: {
-                    readonly var: "event.agent";
-                };
-                readonly stake: {
-                    readonly var: "event.stake";
-                };
-                readonly registeredAt: {
-                    readonly var: "$timestamp";
-                };
-                readonly reputation: {
-                    readonly accuracy: 100;
-                    readonly totalResolutions: 0;
-                    readonly disputesWon: 0;
-                    readonly disputesLost: 0;
-                };
-                readonly domains: {
-                    readonly var: "event.domains";
-                };
-                readonly slashingHistory: readonly [];
-            }];
+        createSchema: {
+            required: readonly ["owner", "displayName"];
+            properties: {
+                owner: {
+                    type: "address";
+                    description: string;
+                    immutable: true;
+                };
+                displayName: {
+                    type: "string";
+                    maxLength: number;
+                    description: string;
+                };
+                bio: {
+                    type: "string";
+                    maxLength: number;
+                    default: string;
+                };
+                avatar: {
+                    type: "uri";
+                    default: null;
+                };
+                platforms: {
+                    type: "array";
+                    items: {
+                        $ref: string;
+                    };
+                    default: never[];
+                };
+            };
         };
-        readonly dependencies: readonly [];
-    }, {
-        readonly from: "REGISTERED";
-        readonly to: "ACTIVE";
-        readonly eventName: "activate";
-        readonly guard: {
-            readonly or: readonly [{
-                readonly "===": readonly [{
-                    readonly var: "event.agent";
-                }, {
-                    readonly var: "state.address";
-                }];
-            }, {
-                readonly var: "event.adminOverride";
-            }];
+        stateSchema: {
+            properties: {
+                owner: {
+                    type: "address";
+                    immutable: true;
+                };
+                displayName: {
+                    type: "string";
+                };
+                bio: {
+                    type: "string";
+                };
+                avatar: {
+                    type: "uri";
+                };
+                platforms: {
+                    type: "array";
+                    items: {
+                        $ref: string;
+                    };
+                };
+                status: {
+                    type: "string";
+                    enum: readonly ["REGISTERED", "ACTIVE", "CHALLENGED", "SUSPENDED", "PROBATION", "WITHDRAWN"];
+                    computed: true;
+                };
+                reputation: {
+                    type: "integer";
+                    default: number;
+                    computed: true;
+                };
+                activatedAt: {
+                    type: "timestamp";
+                    computed: true;
+                };
+                suspendedAt: {
+                    type: "timestamp";
+                    computed: true;
+                };
+                probationStartedAt: {
+                    type: "timestamp";
+                    computed: true;
+                };
+                challengedBy: {
+                    type: "address";
+                    computed: true;
+                };
+            };
         };
-        readonly effect: {
-            readonly merge: readonly [{
-                readonly var: "state";
-            }, {
-                readonly status: "ACTIVE";
-                readonly activatedAt: {
-                    readonly var: "$timestamp";
-                };
-            }];
+        eventSchemas: {
+            activate: {
+                description: string;
+            };
+            receive_vouch: {
+                description: string;
+                required: readonly ["from"];
+                properties: {
+                    from: {
+                        type: "address";
+                        description: string;
+                    };
+                    weight: {
+                        type: "integer";
+                        minimum: number;
+                        maximum: number;
+                        default: number;
+                    };
+                };
+            };
+            receive_completion: {
+                description: string;
+            };
+            challenge: {
+                description: string;
+                required: readonly ["challenger", "reason"];
+                properties: {
+                    challenger: {
+                        type: "address";
+                    };
+                    reason: {
+                        type: "string";
+                        maxLength: number;
+                    };
+                    evidence: {
+                        type: "array";
+                        items: {
+                            type: "uri";
+                        };
+                    };
+                };
+            };
+            dismiss_challenge: {
+                description: string;
+            };
+            uphold_challenge: {
+                description: string;
+            };
+            begin_probation: {
+                description: string;
+            };
+            complete_probation: {
+                description: string;
+            };
+            withdraw: {
+                description: string;
+            };
         };
-        readonly dependencies: readonly [];
-    }, {
-        readonly from: "ACTIVE";
-        readonly to: "ACTIVE";
-        readonly eventName: "add_stake";
-        readonly guard: {
-            readonly and: readonly [{
-                readonly "===": readonly [{
-                    readonly var: "event.agent";
-                }, {
-                    readonly var: "state.address";
-                }];
-            }, {
-                readonly ">": readonly [{
-                    readonly var: "event.amount";
-                }, 0];
-            }];
+        definitions: {
+            PlatformLink: {
+                type: "object";
+                required: readonly ["platform", "handle"];
+                properties: {
+                    platform: {
+                        type: "string";
+                        enum: readonly ["twitter", "github", "discord", "telegram", "moltbook"];
+                    };
+                    handle: {
+                        type: "string";
+                    };
+                    verified: {
+                        type: "boolean";
+                        default: boolean;
+                    };
+                };
+            };
         };
-        readonly effect: {
-            readonly merge: readonly [{
-                readonly var: "state";
-            }, {
-                readonly stake: {
-                    readonly "+": readonly [{
-                        readonly var: "state.stake";
-                    }, {
-                        readonly var: "event.amount";
-                    }];
-                };
-                readonly lastStakeAt: {
-                    readonly var: "$timestamp";
-                };
-            }];
+        states: {
+            REGISTERED: {
+                id: string;
+                isFinal: false;
+            };
+            ACTIVE: {
+                id: string;
+                isFinal: false;
+            };
+            CHALLENGED: {
+                id: string;
+                isFinal: false;
+            };
+            SUSPENDED: {
+                id: string;
+                isFinal: false;
+            };
+            PROBATION: {
+                id: string;
+                isFinal: false;
+            };
+            WITHDRAWN: {
+                id: string;
+                isFinal: true;
+            };
         };
-        readonly dependencies: readonly [];
-    }, {
-        readonly from: "ACTIVE";
-        readonly to: "ACTIVE";
-        readonly eventName: "record_resolution";
-        readonly guard: {
-            readonly var: "event.marketId";
+        initialState: "REGISTERED";
+        transitions: ({
+            from: "REGISTERED";
+            to: "ACTIVE";
+            eventName: "activate";
+            guard: {
+                "==": number[];
+                "!!"?: undefined;
+            };
+            effect: {
+                merge: ({
+                    var: string;
+                    status?: undefined;
+                    activatedAt?: undefined;
+                } | {
+                    status: string;
+                    activatedAt: {
+                        var: string;
+                    };
+                    var?: undefined;
+                })[];
+            };
+        } | {
+            from: "ACTIVE";
+            to: "ACTIVE";
+            eventName: "receive_vouch";
+            guard: {
+                "!!": {
+                    var: string;
+                }[];
+                "=="?: undefined;
+            };
+            effect: {
+                merge: ({
+                    var: string;
+                    reputation?: undefined;
+                } | {
+                    reputation: {
+                        "+": (number | {
+                            var: string;
+                        })[];
+                    };
+                    var?: undefined;
+                })[];
+            };
+        } | {
+            from: "ACTIVE";
+            to: "ACTIVE";
+            eventName: "receive_completion";
+            guard: {
+                "==": number[];
+                "!!"?: undefined;
+            };
+            effect: {
+                merge: ({
+                    var: string;
+                    reputation?: undefined;
+                } | {
+                    reputation: {
+                        "+": (number | {
+                            var: string;
+                        })[];
+                    };
+                    var?: undefined;
+                })[];
+            };
+        } | {
+            from: "ACTIVE";
+            to: "CHALLENGED";
+            eventName: "challenge";
+            guard: {
+                "!!": {
+                    var: string;
+                }[];
+                "=="?: undefined;
+            };
+            effect: {
+                merge: ({
+                    var: string;
+                    status?: undefined;
+                    challengedBy?: undefined;
+                } | {
+                    status: string;
+                    challengedBy: {
+                        var: string;
+                    };
+                    var?: undefined;
+                })[];
+            };
+        } | {
+            from: "CHALLENGED";
+            to: "ACTIVE";
+            eventName: "dismiss_challenge";
+            guard: {
+                "==": number[];
+                "!!"?: undefined;
+            };
+            effect: {
+                merge: ({
+                    var: string;
+                    status?: undefined;
+                    challengedBy?: undefined;
+                } | {
+                    status: string;
+                    challengedBy: null;
+                    var?: undefined;
+                })[];
+            };
+        } | {
+            from: "CHALLENGED";
+            to: "SUSPENDED";
+            eventName: "uphold_challenge";
+            guard: {
+                "==": number[];
+                "!!"?: undefined;
+            };
+            effect: {
+                merge: ({
+                    var: string;
+                    status?: undefined;
+                    suspendedAt?: undefined;
+                } | {
+                    status: string;
+                    suspendedAt: {
+                        var: string;
+                    };
+                    var?: undefined;
+                })[];
+            };
+        } | {
+            from: "SUSPENDED";
+            to: "PROBATION";
+            eventName: "begin_probation";
+            guard: {
+                "==": number[];
+                "!!"?: undefined;
+            };
+            effect: {
+                merge: ({
+                    var: string;
+                    status?: undefined;
+                    probationStartedAt?: undefined;
+                } | {
+                    status: string;
+                    probationStartedAt: {
+                        var: string;
+                    };
+                    var?: undefined;
+                })[];
+            };
+        } | {
+            from: "PROBATION";
+            to: "ACTIVE";
+            eventName: "complete_probation";
+            guard: {
+                "==": number[];
+                "!!"?: undefined;
+            };
+            effect: {
+                merge: ({
+                    var: string;
+                    status?: undefined;
+                    probationStartedAt?: undefined;
+                } | {
+                    status: string;
+                    probationStartedAt: null;
+                    var?: undefined;
+                })[];
+            };
+        } | {
+            from: "ACTIVE";
+            to: "WITHDRAWN";
+            eventName: "withdraw";
+            guard: {
+                "==": number[];
+                "!!"?: undefined;
+            };
+            effect: {
+                merge: ({
+                    var: string;
+                    status?: undefined;
+                } | {
+                    status: string;
+                    var?: undefined;
+                })[];
+            };
+        } | {
+            from: "REGISTERED";
+            to: "WITHDRAWN";
+            eventName: "withdraw";
+            guard: {
+                "==": number[];
+                "!!"?: undefined;
+            };
+            effect: {
+                merge: ({
+                    var: string;
+                    status?: undefined;
+                } | {
+                    status: string;
+                    var?: undefined;
+                })[];
+            };
+        })[];
+    }>;
+    readonly oracle: () => Promise<{
+        metadata: {
+            name: string;
+            app: string;
+            type: string;
+            version: string;
+            description: string;
         };
-        readonly effect: {
-            readonly merge: readonly [{
-                readonly var: "state";
-            }, {
-                readonly reputation: {
-                    readonly merge: readonly [{
-                        readonly var: "state.reputation";
-                    }, {
-                        readonly totalResolutions: {
-                            readonly "+": readonly [{
-                                readonly var: "state.reputation.totalResolutions";
-                            }, 1];
-                        };
-                        readonly accuracy: {
-                            readonly if: readonly [{
-                                readonly var: "event.correct";
-                            }, {
-                                readonly var: "state.reputation.accuracy";
-                            }, {
-                                readonly "-": readonly [{
-                                    readonly var: "state.reputation.accuracy";
-                                }, 5];
-                            }];
-                        };
-                    }];
+        createSchema: {
+            required: readonly ["owner", "stake", "domains"];
+            properties: {
+                owner: {
+                    type: "address";
+                    description: string;
+                    immutable: true;
                 };
-                readonly lastResolutionAt: {
-                    readonly var: "$timestamp";
+                stake: {
+                    type: "integer";
+                    minimum: number;
+                    description: string;
                 };
-            }];
-        };
-        readonly dependencies: readonly [];
-    }, {
-        readonly from: "ACTIVE";
-        readonly to: "SLASHED";
-        readonly eventName: "slash";
-        readonly guard: {
-            readonly and: readonly [{
-                readonly var: "event.reason";
-            }, {
-                readonly ">": readonly [{
-                    readonly var: "event.amount";
-                }, 0];
-            }, {
-                readonly "<=": readonly [{
-                    readonly var: "event.amount";
-                }, {
-                    readonly var: "state.stake";
-                }];
-            }];
+                domains: {
+                    type: "array";
+                    items: {
+                        type: "string";
+                    };
+                    description: string;
+                };
+                minStake: {
+                    type: "integer";
+                    default: number;
+                    description: string;
+                };
+            };
         };
-        readonly effect: {
-            readonly merge: readonly [{
-                readonly var: "state";
-            }, {
-                readonly status: "SLASHED";
-                readonly stake: {
-                    readonly "-": readonly [{
-                        readonly var: "state.stake";
-                    }, {
-                        readonly var: "event.amount";
-                    }];
-                };
-                readonly slashingHistory: {
-                    readonly cat: readonly [{
-                        readonly var: "state.slashingHistory";
-                    }, readonly [{
-                        readonly reason: {
-                            readonly var: "event.reason";
+        stateSchema: {
+            properties: {
+                owner: {
+                    type: "address";
+                    immutable: true;
+                };
+                address: {
+                    type: "address";
+                    computed: true;
+                };
+                stake: {
+                    type: "integer";
+                    computed: true;
+                };
+                minStake: {
+                    type: "integer";
+                };
+                domains: {
+                    type: "array";
+                    items: {
+                        type: "string";
+                    };
+                };
+                status: {
+                    type: "string";
+                    enum: readonly ["UNREGISTERED", "REGISTERED", "ACTIVE", "SLASHED", "WITHDRAWN"];
+                    computed: true;
+                };
+                reputation: {
+                    type: "object";
+                    properties: {
+                        accuracy: {
+                            type: "integer";
                         };
-                        readonly amount: {
-                            readonly var: "event.amount";
+                        totalResolutions: {
+                            type: "integer";
                         };
-                        readonly marketId: {
-                            readonly var: "event.marketId";
+                        disputesWon: {
+                            type: "integer";
                         };
-                        readonly slashedAt: {
-                            readonly var: "$timestamp";
+                        disputesLost: {
+                            type: "integer";
                         };
-                    }]];
+                    };
+                    computed: true;
                 };
-                readonly slashedAt: {
-                    readonly var: "$timestamp";
+                slashingHistory: {
+                    type: "array";
+                    computed: true;
                 };
-            }];
-        };
-        readonly dependencies: readonly [];
-    }, {
-        readonly from: "SLASHED";
-        readonly to: "ACTIVE";
-        readonly eventName: "reactivate";
-        readonly guard: {
-            readonly and: readonly [{
-                readonly "===": readonly [{
-                    readonly var: "event.agent";
-                }, {
-                    readonly var: "state.address";
-                }];
-            }, {
-                readonly ">=": readonly [{
-                    readonly var: "state.stake";
-                }, {
-                    readonly var: "state.minStake";
-                }];
-            }];
-        };
-        readonly effect: {
-            readonly merge: readonly [{
-                readonly var: "state";
-            }, {
-                readonly status: "ACTIVE";
-                readonly reactivatedAt: {
-                    readonly var: "$timestamp";
-                };
-            }];
-        };
-        readonly dependencies: readonly [];
-    }, {
-        readonly from: "ACTIVE";
-        readonly to: "WITHDRAWN";
-        readonly eventName: "withdraw";
-        readonly guard: {
-            readonly "===": readonly [{
-                readonly var: "event.agent";
-            }, {
-                readonly var: "state.address";
-            }];
-        };
-        readonly effect: {
-            readonly merge: readonly [{
-                readonly var: "state";
-            }, {
-                readonly status: "WITHDRAWN";
-                readonly withdrawnAt: {
-                    readonly var: "$timestamp";
-                };
-                readonly finalStake: {
-                    readonly var: "state.stake";
-                };
-            }];
-        };
-        readonly dependencies: readonly [];
-    }, {
-        readonly from: "SLASHED";
-        readonly to: "WITHDRAWN";
-        readonly eventName: "withdraw";
-        readonly guard: {
-            readonly "===": readonly [{
-                readonly var: "event.agent";
-            }, {
-                readonly var: "state.address";
-            }];
-        };
-        readonly effect: {
-            readonly merge: readonly [{
-                readonly var: "state";
-            }, {
-                readonly status: "WITHDRAWN";
-                readonly withdrawnAt: {
-                    readonly var: "$timestamp";
-                };
-                readonly finalStake: {
-                    readonly var: "state.stake";
-                };
-            }];
-        };
-        readonly dependencies: readonly [];
-    }];
-};
-export declare const identityUniversalDef: {
-    readonly metadata: {
-        readonly name: "IdentityUniversal";
-        readonly description: "Minimal identity state machine - extend for custom use cases";
-        readonly version: "1.0.0";
-    };
-    readonly states: {
-        readonly CREATED: {
-            readonly id: "CREATED";
-            readonly isFinal: false;
-            readonly metadata: null;
-        };
-        readonly ACTIVE: {
-            readonly id: "ACTIVE";
-            readonly isFinal: false;
-            readonly metadata: null;
+                registeredAt: {
+                    type: "timestamp";
+                    computed: true;
+                };
+                activatedAt: {
+                    type: "timestamp";
+                    computed: true;
+                };
+                slashedAt: {
+                    type: "timestamp";
+                    computed: true;
+                };
+                withdrawnAt: {
+                    type: "timestamp";
+                    computed: true;
+                };
+            };
         };
-        readonly INACTIVE: {
-            readonly id: "INACTIVE";
-            readonly isFinal: true;
-            readonly metadata: null;
+        eventSchemas: {
+            register: {
+                description: string;
+                required: readonly ["agent", "stake", "domains"];
+                properties: {
+                    agent: {
+                        type: "address";
+                    };
+                    stake: {
+                        type: "integer";
+                        minimum: number;
+                    };
+                    domains: {
+                        type: "array";
+                        items: {
+                            type: "string";
+                        };
+                    };
+                };
+            };
+            activate: {
+                description: string;
+                required: readonly ["agent"];
+                properties: {
+                    agent: {
+                        type: "address";
+                    };
+                    adminOverride: {
+                        type: "boolean";
+                        default: boolean;
+                    };
+                };
+            };
+            add_stake: {
+                description: string;
+                required: readonly ["agent", "amount"];
+                properties: {
+                    agent: {
+                        type: "address";
+                    };
+                    amount: {
+                        type: "integer";
+                        minimum: number;
+                    };
+                };
+            };
+            record_resolution: {
+                description: string;
+                required: readonly ["marketId", "correct"];
+                properties: {
+                    marketId: {
+                        type: "uuid";
+                    };
+                    correct: {
+                        type: "boolean";
+                    };
+                };
+            };
+            slash: {
+                description: string;
+                required: readonly ["reason", "amount"];
+                properties: {
+                    reason: {
+                        type: "string";
+                    };
+                    amount: {
+                        type: "integer";
+                        minimum: number;
+                    };
+                    marketId: {
+                        type: "uuid";
+                    };
+                };
+            };
+            reactivate: {
+                description: string;
+                required: readonly ["agent"];
+                properties: {
+                    agent: {
+                        type: "address";
+                    };
+                };
+            };
+            withdraw: {
+                description: string;
+                required: readonly ["agent"];
+                properties: {
+                    agent: {
+                        type: "address";
+                    };
+                };
+            };
         };
-    };
-    readonly initialState: "CREATED";
-    readonly transitions: readonly [{
-        readonly from: "CREATED";
-        readonly to: "ACTIVE";
-        readonly eventName: "activate";
-        readonly guard: {
-            readonly "==": readonly [1, 1];
+        states: {
+            UNREGISTERED: {
+                id: string;
+                isFinal: false;
+            };
+            REGISTERED: {
+                id: string;
+                isFinal: false;
+            };
+            ACTIVE: {
+                id: string;
+                isFinal: false;
+            };
+            SLASHED: {
+                id: string;
+                isFinal: false;
+            };
+            WITHDRAWN: {
+                id: string;
+                isFinal: true;
+            };
         };
-        readonly effect: {
-            readonly merge: readonly [{
-                readonly var: "state";
-            }, {
-                readonly status: "ACTIVE";
-                readonly activatedAt: {
-                    readonly var: "$timestamp";
-                };
-            }];
+        initialState: "UNREGISTERED";
+        transitions: ({
+            from: "UNREGISTERED";
+            to: "REGISTERED";
+            eventName: "register";
+            guard: {
+                ">=": {
+                    var: string;
+                }[];
+                or?: undefined;
+                and?: undefined;
+                var?: undefined;
+                "==="?: undefined;
+            };
+            effect: {
+                merge: ({
+                    var: string;
+                    status?: undefined;
+                    address?: undefined;
+                    stake?: undefined;
+                    registeredAt?: undefined;
+                    reputation?: undefined;
+                    domains?: undefined;
+                    slashingHistory?: undefined;
+                } | {
+                    status: string;
+                    address: {
+                        var: string;
+                    };
+                    stake: {
+                        var: string;
+                    };
+                    registeredAt: {
+                        var: string;
+                    };
+                    reputation: {
+                        accuracy: number;
+                        totalResolutions: number;
+                        disputesWon: number;
+                        disputesLost: number;
+                    };
+                    domains: {
+                        var: string;
+                    };
+                    slashingHistory: never[];
+                    var?: undefined;
+                })[];
+            };
+        } | {
+            from: "REGISTERED";
+            to: "ACTIVE";
+            eventName: "activate";
+            guard: {
+                or: ({
+                    "===": {
+                        var: string;
+                    }[];
+                    var?: undefined;
+                } | {
+                    var: string;
+                    "==="?: undefined;
+                })[];
+                ">="?: undefined;
+                and?: undefined;
+                var?: undefined;
+                "==="?: undefined;
+            };
+            effect: {
+                merge: ({
+                    var: string;
+                    status?: undefined;
+                    activatedAt?: undefined;
+                } | {
+                    status: string;
+                    activatedAt: {
+                        var: string;
+                    };
+                    var?: undefined;
+                })[];
+            };
+        } | {
+            from: "ACTIVE";
+            to: "ACTIVE";
+            eventName: "add_stake";
+            guard: {
+                and: ({
+                    "===": {
+                        var: string;
+                    }[];
+                    ">"?: undefined;
+                } | {
+                    ">": (number | {
+                        var: string;
+                    })[];
+                    "==="?: undefined;
+                })[];
+                ">="?: undefined;
+                or?: undefined;
+                var?: undefined;
+                "==="?: undefined;
+            };
+            effect: {
+                merge: ({
+                    var: string;
+                    stake?: undefined;
+                    lastStakeAt?: undefined;
+                } | {
+                    stake: {
+                        "+": {
+                            var: string;
+                        }[];
+                    };
+                    lastStakeAt: {
+                        var: string;
+                    };
+                    var?: undefined;
+                })[];
+            };
+        } | {
+            from: "ACTIVE";
+            to: "ACTIVE";
+            eventName: "record_resolution";
+            guard: {
+                var: string;
+                ">="?: undefined;
+                or?: undefined;
+                and?: undefined;
+                "==="?: undefined;
+            };
+            effect: {
+                merge: ({
+                    var: string;
+                    reputation?: undefined;
+                    lastResolutionAt?: undefined;
+                } | {
+                    reputation: {
+                        merge: ({
+                            var: string;
+                            totalResolutions?: undefined;
+                            accuracy?: undefined;
+                        } | {
+                            totalResolutions: {
+                                "+": (number | {
+                                    var: string;
+                                })[];
+                            };
+                            accuracy: {
+                                if: ({
+                                    var: string;
+                                    "-"?: undefined;
+                                } | {
+                                    "-": (number | {
+                                        var: string;
+                                    })[];
+                                    var?: undefined;
+                                })[];
+                            };
+                            var?: undefined;
+                        })[];
+                    };
+                    lastResolutionAt: {
+                        var: string;
+                    };
+                    var?: undefined;
+                })[];
+            };
+        } | {
+            from: "ACTIVE";
+            to: "SLASHED";
+            eventName: "slash";
+            guard: {
+                and: ({
+                    var: string;
+                    ">"?: undefined;
+                    "<="?: undefined;
+                } | {
+                    ">": (number | {
+                        var: string;
+                    })[];
+                    var?: undefined;
+                    "<="?: undefined;
+                } | {
+                    "<=": {
+                        var: string;
+                    }[];
+                    var?: undefined;
+                    ">"?: undefined;
+                })[];
+                ">="?: undefined;
+                or?: undefined;
+                var?: undefined;
+                "==="?: undefined;
+            };
+            effect: {
+                merge: ({
+                    var: string;
+                    status?: undefined;
+                    stake?: undefined;
+                    slashingHistory?: undefined;
+                    slashedAt?: undefined;
+                } | {
+                    status: string;
+                    stake: {
+                        "-": {
+                            var: string;
+                        }[];
+                    };
+                    slashingHistory: {
+                        cat: ({
+                            var: string;
+                        } | {
+                            reason: {
+                                var: string;
+                            };
+                            amount: {
+                                var: string;
+                            };
+                            marketId: {
+                                var: string;
+                            };
+                            slashedAt: {
+                                var: string;
+                            };
+                        }[])[];
+                    };
+                    slashedAt: {
+                        var: string;
+                    };
+                    var?: undefined;
+                })[];
+            };
+        } | {
+            from: "SLASHED";
+            to: "ACTIVE";
+            eventName: "reactivate";
+            guard: {
+                and: ({
+                    "===": {
+                        var: string;
+                    }[];
+                    ">="?: undefined;
+                } | {
+                    ">=": {
+                        var: string;
+                    }[];
+                    "==="?: undefined;
+                })[];
+                ">="?: undefined;
+                or?: undefined;
+                var?: undefined;
+                "==="?: undefined;
+            };
+            effect: {
+                merge: ({
+                    var: string;
+                    status?: undefined;
+                    reactivatedAt?: undefined;
+                } | {
+                    status: string;
+                    reactivatedAt: {
+                        var: string;
+                    };
+                    var?: undefined;
+                })[];
+            };
+        } | {
+            from: "ACTIVE";
+            to: "WITHDRAWN";
+            eventName: "withdraw";
+            guard: {
+                "===": {
+                    var: string;
+                }[];
+                ">="?: undefined;
+                or?: undefined;
+                and?: undefined;
+                var?: undefined;
+            };
+            effect: {
+                merge: ({
+                    var: string;
+                    status?: undefined;
+                    withdrawnAt?: undefined;
+                    finalStake?: undefined;
+                } | {
+                    status: string;
+                    withdrawnAt: {
+                        var: string;
+                    };
+                    finalStake: {
+                        var: string;
+                    };
+                    var?: undefined;
+                })[];
+            };
+        } | {
+            from: "SLASHED";
+            to: "WITHDRAWN";
+            eventName: "withdraw";
+            guard: {
+                "===": {
+                    var: string;
+                }[];
+                ">="?: undefined;
+                or?: undefined;
+                and?: undefined;
+                var?: undefined;
+            };
+            effect: {
+                merge: ({
+                    var: string;
+                    status?: undefined;
+                    withdrawnAt?: undefined;
+                    finalStake?: undefined;
+                } | {
+                    status: string;
+                    withdrawnAt: {
+                        var: string;
+                    };
+                    finalStake: {
+                        var: string;
+                    };
+                    var?: undefined;
+                })[];
+            };
+        })[];
+    }>;
+    readonly universal: () => Promise<{
+        metadata: {
+            name: string;
+            app: string;
+            type: string;
+            version: string;
+            description: string;
         };
-        readonly dependencies: readonly [];
-    }, {
-        readonly from: "ACTIVE";
-        readonly to: "ACTIVE";
-        readonly eventName: "update";
-        readonly guard: {
-            readonly "==": readonly [1, 1];
+        createSchema: {
+            required: readonly ["owner"];
+            properties: {
+                owner: {
+                    type: "address";
+                    description: string;
+                    immutable: true;
+                };
+                metadata: {
+                    type: "object";
+                    description: string;
+                    default: {};
+                };
+            };
         };
-        readonly effect: {
-            readonly merge: readonly [{
-                readonly var: "state";
-            }, {
-                readonly updatedAt: {
-                    readonly var: "$timestamp";
+        stateSchema: {
+            properties: {
+                owner: {
+                    type: "address";
+                    immutable: true;
                 };
-                readonly metadata: {
-                    readonly var: "event.metadata";
+                status: {
+                    type: "string";
+                    enum: readonly ["CREATED", "ACTIVE", "INACTIVE"];
+                    computed: true;
                 };
-            }];
+                metadata: {
+                    type: "object";
+                };
+                activatedAt: {
+                    type: "timestamp";
+                    computed: true;
+                };
+                updatedAt: {
+                    type: "timestamp";
+                    computed: true;
+                };
+                deactivatedAt: {
+                    type: "timestamp";
+                    computed: true;
+                };
+            };
         };
-        readonly dependencies: readonly [];
-    }, {
-        readonly from: "ACTIVE";
-        readonly to: "INACTIVE";
-        readonly eventName: "deactivate";
-        readonly guard: {
-            readonly "==": readonly [1, 1];
+        eventSchemas: {
+            activate: {
+                description: string;
+            };
+            update: {
+                description: string;
+                properties: {
+                    metadata: {
+                        type: "object";
+                    };
+                };
+            };
+            deactivate: {
+                description: string;
+            };
         };
-        readonly effect: {
-            readonly merge: readonly [{
-                readonly var: "state";
-            }, {
-                readonly status: "INACTIVE";
-                readonly deactivatedAt: {
-                    readonly var: "$timestamp";
-                };
-            }];
+        states: {
+            CREATED: {
+                id: string;
+                isFinal: false;
+            };
+            ACTIVE: {
+                id: string;
+                isFinal: false;
+            };
+            INACTIVE: {
+                id: string;
+                isFinal: true;
+            };
         };
-        readonly dependencies: readonly [];
-    }];
+        initialState: "CREATED";
+        transitions: ({
+            from: "CREATED";
+            to: "ACTIVE";
+            eventName: "activate";
+            guard: {
+                "==": number[];
+            };
+            effect: {
+                merge: ({
+                    var: string;
+                    status?: undefined;
+                    activatedAt?: undefined;
+                } | {
+                    status: string;
+                    activatedAt: {
+                        var: string;
+                    };
+                    var?: undefined;
+                })[];
+            };
+        } | {
+            from: "ACTIVE";
+            to: "ACTIVE";
+            eventName: "update";
+            guard: {
+                "==": number[];
+            };
+            effect: {
+                merge: ({
+                    var: string;
+                    updatedAt?: undefined;
+                    metadata?: undefined;
+                } | {
+                    updatedAt: {
+                        var: string;
+                    };
+                    metadata: {
+                        var: string;
+                    };
+                    var?: undefined;
+                })[];
+            };
+        } | {
+            from: "ACTIVE";
+            to: "INACTIVE";
+            eventName: "deactivate";
+            guard: {
+                "==": number[];
+            };
+            effect: {
+                merge: ({
+                    var: string;
+                    status?: undefined;
+                    deactivatedAt?: undefined;
+                } | {
+                    status: string;
+                    deactivatedAt: {
+                        var: string;
+                    };
+                    var?: undefined;
+                })[];
+            };
+        })[];
+    }>;
 };
+export type IdentityType = keyof typeof IDENTITY_DEFINITIONS;