@ottochain/sdk 2.0.0 → 2.1.0

package/dist/types/apps/identity/index.d.ts

@@ -16,9 +16,10 @@
  *
  * @packageDocumentation
  */
-export { AgentState, Platform, PlatformLink, AgentIdentity, AgentIdentityDefinition, agentStateFromJSON, agentStateToJSON, platformFromJSON, platformToJSON, } from '../../generated/ottochain/apps/identity/v1/agent.js';
-export { AttestationType, ReputationDelta, Attestation, VouchRequest, ChallengeRequest, ReputationConfig, attestationTypeFromJSON, attestationTypeToJSON, } from '../../generated/ottochain/apps/identity/v1/attestation.js';
-export { AGENT_TRANSITIONS, ATTESTATION_DELTAS, canTransition, getReputationDelta, } from './constants.js';
+export { IdentityType, IdentityState, Platform, PlatformLink, Reputation, PenaltyEvent, Identity, RegisterIdentityRequest, ActivateIdentityRequest, LinkPlatformRequest, ChallengeIdentityRequest, AddStakeRequest, WithdrawIdentityRequest, IdentityDefinition, identityTypeFromJSON, identityTypeToJSON, identityStateFromJSON, identityStateToJSON, platformFromJSON, platformToJSON, } from "../../generated/ottochain/apps/identity/v1/identity.js";
+export { IdentityState as AgentState } from "../../generated/ottochain/apps/identity/v1/identity.js";
+export { AttestationType, ReputationDelta, Attestation, VouchRequest, ChallengeRequest, ReputationConfig, attestationTypeFromJSON, attestationTypeToJSON, } from "../../generated/ottochain/apps/identity/v1/attestation.js";
+export { IDENTITY_TRANSITIONS, AGENT_TRANSITIONS, ATTESTATION_DELTAS, canTransition, getReputationDelta, } from "./constants.js";
 /**
  * Default reputation configuration for agent identity
  */
@@ -31,606 +32,1106 @@ export declare const DEFAULT_REPUTATION_CONFIG: {
     readonly minReputation: 0;
     readonly challengeThreshold: 5;
 };
-import { identityUniversalDef, identityAgentDef, identityOracleDef } from './state-machines/index.js';
+import { identityUniversalDef, identityAgentDef, identityOracleDef } from "./state-machines/index.js";
 export { identityUniversalDef, identityAgentDef, identityOracleDef };
 /** All identity state machine definitions */
 export declare const IDENTITY_DEFINITIONS: {
     readonly universal: {
-        readonly metadata: {
-            readonly name: "IdentityUniversal";
-            readonly description: "Minimal identity state machine - extend for custom use cases";
-            readonly version: "1.0.0";
+        metadata: {
+            name: string;
+            app: string;
+            type: string;
+            version: string;
+            description: string;
         };
-        readonly states: {
-            readonly CREATED: {
-                readonly id: "CREATED";
-                readonly isFinal: false;
-                readonly metadata: null;
-            };
-            readonly ACTIVE: {
-                readonly id: "ACTIVE";
-                readonly isFinal: false;
-                readonly metadata: null;
-            };
-            readonly INACTIVE: {
-                readonly id: "INACTIVE";
-                readonly isFinal: true;
-                readonly metadata: null;
+        createSchema: {
+            required: readonly ["owner"];
+            properties: {
+                owner: {
+                    type: "address";
+                    description: string;
+                    immutable: true;
+                };
+                metadata: {
+                    type: "object";
+                    description: string;
+                    default: {};
+                };
             };
         };
-        readonly initialState: "CREATED";
-        readonly transitions: readonly [{
-            readonly from: "CREATED";
-            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: "update";
-            readonly guard: {
-                readonly "==": readonly [1, 1];
-            };
-            readonly effect: {
-                readonly merge: readonly [{
-                    readonly var: "state";
-                }, {
-                    readonly updatedAt: {
-                        readonly var: "$timestamp";
-                    };
-                    readonly metadata: {
-                        readonly var: "event.metadata";
-                    };
-                }];
-            };
-            readonly dependencies: readonly [];
-        }, {
-            readonly from: "ACTIVE";
-            readonly to: "INACTIVE";
-            readonly eventName: "deactivate";
-            readonly guard: {
-                readonly "==": readonly [1, 1];
-            };
-            readonly effect: {
-                readonly merge: readonly [{
-                    readonly var: "state";
-                }, {
-                    readonly status: "INACTIVE";
-                    readonly deactivatedAt: {
-                        readonly var: "$timestamp";
-                    };
-                }];
-            };
-            readonly dependencies: readonly [];
-        }];
+        stateSchema: {
+            properties: {
+                owner: {
+                    type: "address";
+                    immutable: true;
+                };
+                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;
+                };
+            };
+        };
+        eventSchemas: {
+            activate: {
+                description: string;
+            };
+            update: {
+                description: string;
+                properties: {
+                    metadata: {
+                        type: "object";
+                    };
+                };
+            };
+            deactivate: {
+                description: string;
+            };
+        };
+        states: {
+            CREATED: {
+                id: string;
+                isFinal: false;
+            };
+            ACTIVE: {
+                id: string;
+                isFinal: false;
+            };
+            /**
+             * Default reputation configuration for agent identity
+             */
+            INACTIVE: {
+                id: string;
+                isFinal: true;
+            };
+        };
+        initialState: "CREATED"; /**
+         * Default reputation configuration for agent identity
+         */
+        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;
+                })[];
+            };
+        })[];
     };
     readonly agent: {
-        readonly metadata: {
-            readonly name: "IdentityAgent";
-            readonly description: "Standard agent identity with reputation tracking, vouching, and lifecycle management";
-            readonly version: "1.0.0";
+        metadata: {
+            name: string;
+            app: string;
+            type: string;
+            version: string;
+            description: string;
         };
-        readonly states: {
-            readonly REGISTERED: {
-                readonly id: "REGISTERED";
-                readonly isFinal: false;
-                readonly metadata: null;
-            };
-            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;
+        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 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 [];
-        }];
+        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;
+                };
+            };
+        };
+        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;
+            };
+        };
+        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;
+                    };
+                };
+            };
+        };
+        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;
+            };
+        };
+        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: {
-        readonly metadata: {
-            readonly name: "IdentityOracle";
-            readonly description: "Oracle identity with staking, attestations, reputation, and slashing mechanics";
-            readonly version: "1.0.0";
+        metadata: {
+            name: string;
+            app: string;
+            type: string;
+            version: string;
+            description: string;
+        };
+        createSchema: {
+            required: readonly ["owner", "stake", "domains"];
+            properties: {
+                owner: {
+                    type: "address";
+                    description: string;
+                    immutable: true;
+                };
+                stake: {
+                    type: "integer";
+                    minimum: number;
+                    description: string;
+                };
+                domains: {
+                    type: "array";
+                    items: {
+                        type: "string";
+                    };
+                    description: string;
+                };
+                minStake: {
+                    type: "integer";
+                    default: number;
+                    description: string;
+                };
+            };
+        };
+        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";
+                        };
+                        totalResolutions: {
+                            type: "integer";
+                        };
+                        disputesWon: {
+                            type: "integer";
+                        };
+                        disputesLost: {
+                            type: "integer";
+                        };
+                    };
+                    computed: true;
+                };
+                slashingHistory: {
+                    type: "array";
+                    computed: true;
+                };
+                registeredAt: {
+                    type: "timestamp";
+                    computed: true;
+                };
+                activatedAt: {
+                    type: "timestamp";
+                    computed: true;
+                };
+                slashedAt: {
+                    type: "timestamp";
+                    computed: true;
+                };
+                withdrawnAt: {
+                    type: "timestamp";
+                    computed: true;
+                };
+            };
+        };
+        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 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;
+        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 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 [];
-                }];
-            };
-            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";
-                }];
-            };
-            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: "add_stake";
-            readonly guard: {
-                readonly and: readonly [{
-                    readonly "===": readonly [{
-                        readonly var: "event.agent";
-                    }, {
-                        readonly var: "state.address";
-                    }];
-                }, {
-                    readonly ">": readonly [{
-                        readonly var: "event.amount";
-                    }, 0];
-                }];
-            };
-            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";
-                    };
-                }];
-            };
-            readonly dependencies: readonly [];
-        }, {
-            readonly from: "ACTIVE";
-            readonly to: "ACTIVE";
-            readonly eventName: "record_resolution";
-            readonly guard: {
-                readonly var: "event.marketId";
-            };
-            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];
+        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;
+                                })[];
                             };
-                            readonly accuracy: {
-                                readonly if: readonly [{
-                                    readonly var: "event.correct";
-                                }, {
-                                    readonly var: "state.reputation.accuracy";
-                                }, {
-                                    readonly "-": readonly [{
-                                        readonly var: "state.reputation.accuracy";
-                                    }, 5];
-                                }];
+                            accuracy: {
+                                if: ({
+                                    var: string;
+                                    "-"?: undefined;
+                                } | {
+                                    "-": (number | {
+                                        var: string;
+                                    })[];
+                                    var?: undefined;
+                                })[];
                             };
-                        }];
-                    };
-                    readonly lastResolutionAt: {
-                        readonly var: "$timestamp";
-                    };
-                }];
-            };
-            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";
-                    }];
-                }];
-            };
-            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";
+                            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;
                             };
-                            readonly amount: {
-                                readonly var: "event.amount";
+                            amount: {
+                                var: string;
                             };
-                            readonly marketId: {
-                                readonly var: "event.marketId";
+                            marketId: {
+                                var: string;
                             };
-                            readonly slashedAt: {
-                                readonly var: "$timestamp";
+                            slashedAt: {
+                                var: string;
                             };
-                        }]];
-                    };
-                    readonly slashedAt: {
-                        readonly var: "$timestamp";
-                    };
-                }];
-            };
-            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 [];
-        }];
+                        }[])[];
+                    };
+                    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;
+                })[];
+            };
+        })[];
     };
 };
-export type IdentityType = keyof typeof IDENTITY_DEFINITIONS;
+export type IdentityDefType = keyof typeof IDENTITY_DEFINITIONS;
 /**
  * Get an identity state machine definition by type.
  * @param type - 'universal' | 'agent' | 'oracle' (default: 'agent')
  */
-export declare function getIdentityDefinition(type?: IdentityType): unknown;
+export declare function getIdentityDefinition(type?: IdentityDefType): unknown;