@ottochain/sdk 2.2.1 → 2.2.3

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

@@ -20,805 +20,1120 @@
  */
 export { ContractState, Contract, ProposeContractRequest, AcceptContractRequest, CompleteContractRequest, RejectContractRequest, DisputeContractRequest, ContractDefinition, contractStateFromJSON, contractStateToJSON, } from "../../generated/ottochain/apps/contracts/v1/contract.js";
 import { contractUniversalDef, contractAgreementDef, contractEscrowDef } from "./state-machines/index.js";
+import type { FiberAppDefinition } from "../../schema/fiber-app.js";
 export { contractUniversalDef, contractAgreementDef, contractEscrowDef };
 /** All contract state machine definitions */
 export declare const CONTRACTS_DEFINITIONS: {
     readonly universal: {
-        readonly metadata: {
-            readonly name: "ContractUniversal";
-            readonly description: "Minimal contract state machine - extend for custom use cases";
-            readonly version: "1.0.0";
-            readonly app: "contracts";
-            readonly type: "universal";
+        metadata: {
+            name: string;
+            app: string;
+            type: string;
+            version: string;
+            description: string;
         };
-        readonly createSchema: {
-            readonly properties: {};
+        createSchema: {
+            properties: {};
         };
-        readonly stateSchema: {
-            readonly properties: {
-                readonly status: {
-                    readonly type: "string";
+        stateSchema: {
+            properties: {
+                status: {
+                    type: "string";
+                };
+                acceptedAt: {
+                    type: "integer";
+                    nullable: true;
+                };
+                cancelledAt: {
+                    type: "integer";
+                    nullable: true;
+                };
+                completedAt: {
+                    type: "integer";
+                    nullable: true;
                 };
             };
         };
-        readonly eventSchemas: {
-            readonly accept: {};
-            readonly cancel: {};
-            readonly complete: {};
+        eventSchemas: {
+            accept: {};
+            cancel: {};
+            complete: {};
         };
-        readonly states: {
-            readonly PROPOSED: {
-                readonly id: "PROPOSED";
-                readonly isFinal: false;
-                readonly metadata: null;
-            };
-            readonly ACTIVE: {
-                readonly id: "ACTIVE";
-                readonly isFinal: false;
-                readonly metadata: null;
-            };
-            readonly COMPLETED: {
-                readonly id: "COMPLETED";
-                readonly isFinal: true;
-                readonly metadata: null;
-            };
-            readonly CANCELLED: {
-                readonly id: "CANCELLED";
-                readonly isFinal: true;
-                readonly metadata: null;
+        states: {
+            PROPOSED: {
+                id: string;
+                isFinal: false;
+                metadata: null;
+            };
+            ACTIVE: {
+                id: string;
+                isFinal: false;
+                metadata: null;
+            };
+            COMPLETED: {
+                id: string;
+                isFinal: true;
+                metadata: null;
+            };
+            CANCELLED: {
+                id: string;
+                isFinal: true;
+                metadata: null;
             };
         };
-        readonly initialState: "PROPOSED";
-        readonly transitions: readonly [{
-            readonly from: "PROPOSED";
-            readonly to: "ACTIVE";
-            readonly eventName: "accept";
-            readonly guard: {
-                readonly "==": readonly [1, 1];
-            };
-            readonly effect: {
-                readonly merge: readonly [{
-                    readonly var: "state";
-                }, {
-                    readonly status: "ACTIVE";
-                    readonly acceptedAt: {
-                        readonly var: "$timestamp";
-                    };
-                }];
-            };
-            readonly dependencies: readonly [];
-        }, {
-            readonly from: "PROPOSED";
-            readonly to: "CANCELLED";
-            readonly eventName: "cancel";
-            readonly guard: {
-                readonly "==": readonly [1, 1];
-            };
-            readonly effect: {
-                readonly merge: readonly [{
-                    readonly var: "state";
-                }, {
-                    readonly status: "CANCELLED";
-                    readonly cancelledAt: {
-                        readonly var: "$timestamp";
-                    };
-                }];
-            };
-            readonly dependencies: readonly [];
-        }, {
-            readonly from: "ACTIVE";
-            readonly to: "COMPLETED";
-            readonly eventName: "complete";
-            readonly guard: {
-                readonly "==": readonly [1, 1];
-            };
-            readonly effect: {
-                readonly merge: readonly [{
-                    readonly var: "state";
-                }, {
-                    readonly status: "COMPLETED";
-                    readonly completedAt: {
-                        readonly var: "$timestamp";
-                    };
-                }];
-            };
-            readonly dependencies: readonly [];
-        }, {
-            readonly from: "ACTIVE";
-            readonly to: "CANCELLED";
-            readonly eventName: "cancel";
-            readonly guard: {
-                readonly "==": readonly [1, 1];
-            };
-            readonly effect: {
-                readonly merge: readonly [{
-                    readonly var: "state";
-                }, {
-                    readonly status: "CANCELLED";
-                    readonly cancelledAt: {
-                        readonly var: "$timestamp";
-                    };
-                }];
-            };
-            readonly dependencies: readonly [];
-        }];
+        initialState: "PROPOSED";
+        transitions: ({
+            from: "PROPOSED";
+            to: "ACTIVE";
+            eventName: "accept";
+            guard: {
+                "==": number[];
+            };
+            effect: {
+                merge: ({
+                    var: string;
+                    status?: undefined;
+                    acceptedAt?: undefined;
+                } | {
+                    status: string;
+                    acceptedAt: {
+                        var: string;
+                    };
+                    var?: undefined;
+                })[];
+            };
+            dependencies: never[];
+        } | {
+            from: "PROPOSED";
+            to: "CANCELLED";
+            eventName: "cancel";
+            guard: {
+                "==": number[];
+            };
+            effect: {
+                merge: ({
+                    var: string;
+                    status?: undefined;
+                    cancelledAt?: undefined;
+                } | {
+                    status: string;
+                    cancelledAt: {
+                        var: string;
+                    };
+                    var?: undefined;
+                })[];
+            };
+            dependencies: never[];
+        } | {
+            from: "ACTIVE";
+            to: "COMPLETED";
+            eventName: "complete";
+            guard: {
+                "==": number[];
+            };
+            effect: {
+                merge: ({
+                    var: string;
+                    status?: undefined;
+                    completedAt?: undefined;
+                } | {
+                    status: string;
+                    completedAt: {
+                        var: string;
+                    };
+                    var?: undefined;
+                })[];
+            };
+            dependencies: never[];
+        } | {
+            from: "ACTIVE";
+            to: "CANCELLED";
+            eventName: "cancel";
+            guard: {
+                "==": number[];
+            };
+            effect: {
+                merge: ({
+                    var: string;
+                    status?: undefined;
+                    cancelledAt?: undefined;
+                } | {
+                    status: string;
+                    cancelledAt: {
+                        var: string;
+                    };
+                    var?: undefined;
+                })[];
+            };
+            dependencies: never[];
+        })[];
     };
     readonly agreement: {
-        readonly metadata: {
-            readonly name: "ContractAgreement";
-            readonly description: "Two-party agreement with mutual completion attestation and dispute resolution";
-            readonly version: "1.0.0";
-            readonly app: "contracts";
-            readonly type: "agreement";
-            readonly crossReferences: {
-                readonly proposerIdentityId: "Links to proposer's AgentIdentity fiber";
-                readonly counterpartyIdentityId: "Links to counterparty's AgentIdentity fiber";
-                readonly escrowId: "Links to Escrow if payment is escrowed";
-                readonly arbitrationPoolId: "Links to ArbitrationPool for dispute resolution";
+        metadata: {
+            name: string;
+            app: string;
+            type: string;
+            version: string;
+            description: string;
+            crossReferences: {
+                proposerIdentityId: {
+                    machine: string;
+                    field: string;
+                    description: string;
+                };
+                counterpartyIdentityId: {
+                    machine: string;
+                    field: string;
+                    description: string;
+                };
+                escrowId: {
+                    machine: string;
+                    field: string;
+                    description: string;
+                };
+                arbitrationPoolId: {
+                    machine: string;
+                    field: string;
+                    description: string;
+                };
             };
         };
-        readonly createSchema: {
-            readonly required: readonly ["proposer", "counterparty"];
-            readonly properties: {
-                readonly proposer: {
-                    readonly type: "address";
-                    readonly description: "DAG address of the proposer";
-                    readonly immutable: true;
+        createSchema: {
+            required: readonly ["proposer", "counterparty"];
+            properties: {
+                proposer: {
+                    type: "address";
+                    description: string;
+                    immutable: true;
                 };
-                readonly counterparty: {
-                    readonly type: "address";
-                    readonly description: "DAG address of the counterparty";
-                    readonly immutable: true;
+                counterparty: {
+                    type: "address";
+                    description: string;
+                    immutable: true;
                 };
             };
         };
-        readonly stateSchema: {
-            readonly properties: {
-                readonly status: {
-                    readonly type: "string";
+        stateSchema: {
+            properties: {
+                status: {
+                    type: "string";
+                };
+                proposer: {
+                    type: "address";
+                };
+                counterparty: {
+                    type: "address";
                 };
-                readonly proposer: {
-                    readonly type: "address";
+                completions: {
+                    type: "array";
                 };
-                readonly counterparty: {
-                    readonly type: "address";
+                acceptedAt: {
+                    type: "integer";
+                    nullable: true;
                 };
-                readonly completions: {
-                    readonly type: "array";
+                rejectedAt: {
+                    type: "integer";
+                    nullable: true;
+                };
+                rejectReason: {
+                    type: "string";
+                    nullable: true;
+                };
+                cancelledAt: {
+                    type: "integer";
+                    nullable: true;
+                };
+                completedAt: {
+                    type: "integer";
+                    nullable: true;
+                };
+                disputedAt: {
+                    type: "integer";
+                    nullable: true;
+                };
+                disputeReason: {
+                    type: "string";
+                    nullable: true;
+                };
+                disputedBy: {
+                    type: "address";
+                    nullable: true;
+                };
+                resolvedAt: {
+                    type: "integer";
+                    nullable: true;
+                };
+                resolution: {
+                    type: "string";
+                    nullable: true;
+                };
+                rulingId: {
+                    type: "string";
+                    nullable: true;
                 };
             };
         };
-        readonly eventSchemas: {
-            readonly accept: {};
-            readonly reject: {};
-            readonly cancel: {};
-            readonly submit_completion: {};
-            readonly finalize: {};
-            readonly dispute: {};
-            readonly resolve: {};
+        eventSchemas: {
+            accept: {};
+            reject: {
+                properties: {
+                    reason: {
+                        type: "string";
+                    };
+                };
+            };
+            cancel: {};
+            submit_completion: {
+                properties: {
+                    proof: {
+                        type: "string";
+                    };
+                };
+            };
+            finalize: {};
+            dispute: {
+                properties: {
+                    reason: {
+                        type: "string";
+                    };
+                };
+            };
+            resolve: {
+                properties: {
+                    judicialRuling: {
+                        type: "boolean";
+                        nullable: true;
+                    };
+                    proposerApproves: {
+                        type: "boolean";
+                        nullable: true;
+                    };
+                    counterpartyApproves: {
+                        type: "boolean";
+                        nullable: true;
+                    };
+                    resolution: {
+                        type: "string";
+                    };
+                    rulingId: {
+                        type: "string";
+                        nullable: true;
+                    };
+                };
+            };
         };
-        readonly states: {
-            readonly PROPOSED: {
-                readonly id: "PROPOSED";
-                readonly isFinal: false;
-                readonly metadata: null;
-            };
-            readonly ACTIVE: {
-                readonly id: "ACTIVE";
-                readonly isFinal: false;
-                readonly metadata: null;
-            };
-            readonly COMPLETED: {
-                readonly id: "COMPLETED";
-                readonly isFinal: true;
-                readonly metadata: null;
-            };
-            readonly DISPUTED: {
-                readonly id: "DISPUTED";
-                readonly isFinal: false;
-                readonly metadata: null;
-            };
-            readonly REJECTED: {
-                readonly id: "REJECTED";
-                readonly isFinal: true;
-                readonly metadata: null;
-            };
-            readonly CANCELLED: {
-                readonly id: "CANCELLED";
-                readonly isFinal: true;
-                readonly metadata: null;
+        states: {
+            PROPOSED: {
+                id: string;
+                isFinal: false;
+                metadata: null;
+            };
+            ACTIVE: {
+                id: string;
+                isFinal: false;
+                metadata: null;
+            };
+            COMPLETED: {
+                id: string;
+                isFinal: true;
+                metadata: null;
+            };
+            DISPUTED: {
+                id: string;
+                isFinal: false;
+                metadata: null;
+            };
+            REJECTED: {
+                id: string;
+                isFinal: true;
+                metadata: null;
+            };
+            CANCELLED: {
+                id: string;
+                isFinal: true;
+                metadata: null;
             };
         };
-        readonly initialState: "PROPOSED";
-        readonly transitions: readonly [{
-            readonly from: "PROPOSED";
-            readonly to: "ACTIVE";
-            readonly eventName: "accept";
-            readonly guard: {
-                readonly "===": readonly [{
-                    readonly var: "event.agent";
-                }, {
-                    readonly var: "state.counterparty";
-                }];
-            };
-            readonly effect: {
-                readonly merge: readonly [{
-                    readonly var: "state";
-                }, {
-                    readonly status: "ACTIVE";
-                    readonly acceptedAt: {
-                        readonly var: "$timestamp";
-                    };
-                }];
-            };
-            readonly dependencies: readonly [];
-        }, {
-            readonly from: "PROPOSED";
-            readonly to: "REJECTED";
-            readonly eventName: "reject";
-            readonly guard: {
-                readonly "===": readonly [{
-                    readonly var: "event.agent";
-                }, {
-                    readonly var: "state.counterparty";
-                }];
-            };
-            readonly effect: {
-                readonly merge: readonly [{
-                    readonly var: "state";
-                }, {
-                    readonly status: "REJECTED";
-                    readonly rejectedAt: {
-                        readonly var: "$timestamp";
-                    };
-                    readonly rejectReason: {
-                        readonly var: "event.reason";
-                    };
-                }];
-            };
-            readonly dependencies: readonly [];
-        }, {
-            readonly from: "PROPOSED";
-            readonly to: "CANCELLED";
-            readonly eventName: "cancel";
-            readonly guard: {
-                readonly "===": readonly [{
-                    readonly var: "event.agent";
-                }, {
-                    readonly var: "state.proposer";
-                }];
-            };
-            readonly effect: {
-                readonly merge: readonly [{
-                    readonly var: "state";
-                }, {
-                    readonly status: "CANCELLED";
-                    readonly cancelledAt: {
-                        readonly var: "$timestamp";
-                    };
-                }];
-            };
-            readonly dependencies: readonly [];
-        }, {
-            readonly from: "ACTIVE";
-            readonly to: "ACTIVE";
-            readonly eventName: "submit_completion";
-            readonly guard: {
-                readonly and: readonly [{
-                    readonly or: readonly [{
-                        readonly "===": readonly [{
-                            readonly var: "event.agent";
-                        }, {
-                            readonly var: "state.proposer";
-                        }];
-                    }, {
-                        readonly "===": readonly [{
-                            readonly var: "event.agent";
-                        }, {
-                            readonly var: "state.counterparty";
-                        }];
-                    }];
-                }, {
-                    readonly "!": readonly [{
-                        readonly in: readonly [{
-                            readonly var: "event.agent";
-                        }, {
-                            readonly map: readonly [{
-                                readonly var: "state.completions";
-                            }, {
-                                readonly var: "agent";
-                            }];
-                        }];
-                    }];
-                }];
-            };
-            readonly effect: {
-                readonly merge: readonly [{
-                    readonly var: "state";
-                }, {
-                    readonly completions: {
-                        readonly cat: readonly [{
-                            readonly var: "state.completions";
-                        }, readonly [{
-                            readonly agent: {
-                                readonly var: "event.agent";
+        initialState: "PROPOSED";
+        transitions: ({
+            from: "PROPOSED";
+            to: "ACTIVE";
+            eventName: "accept";
+            guard: {
+                "===": {
+                    var: string;
+                }[];
+                and?: undefined;
+                ">="?: undefined;
+                or?: undefined;
+            };
+            effect: {
+                merge: ({
+                    var: string;
+                    status?: undefined;
+                    acceptedAt?: undefined;
+                } | {
+                    status: string;
+                    acceptedAt: {
+                        var: string;
+                    };
+                    var?: undefined;
+                })[];
+            };
+            dependencies: never[];
+        } | {
+            from: "PROPOSED";
+            to: "REJECTED";
+            eventName: "reject";
+            guard: {
+                "===": {
+                    var: string;
+                }[];
+                and?: undefined;
+                ">="?: undefined;
+                or?: undefined;
+            };
+            effect: {
+                merge: ({
+                    var: string;
+                    status?: undefined;
+                    rejectedAt?: undefined;
+                    rejectReason?: undefined;
+                } | {
+                    status: string;
+                    rejectedAt: {
+                        var: string;
+                    };
+                    rejectReason: {
+                        var: string;
+                    };
+                    var?: undefined;
+                })[];
+            };
+            dependencies: never[];
+        } | {
+            from: "PROPOSED";
+            to: "CANCELLED";
+            eventName: "cancel";
+            guard: {
+                "===": {
+                    var: string;
+                }[];
+                and?: undefined;
+                ">="?: undefined;
+                or?: undefined;
+            };
+            effect: {
+                merge: ({
+                    var: string;
+                    status?: undefined;
+                    cancelledAt?: undefined;
+                } | {
+                    status: string;
+                    cancelledAt: {
+                        var: string;
+                    };
+                    var?: undefined;
+                })[];
+            };
+            dependencies: never[];
+        } | {
+            from: "ACTIVE";
+            to: "ACTIVE";
+            eventName: "submit_completion";
+            guard: {
+                and: ({
+                    or: {
+                        "===": {
+                            var: string;
+                        }[];
+                    }[];
+                    "!"?: undefined;
+                } | {
+                    "!": {
+                        in: ({
+                            var: string;
+                            map?: undefined;
+                        } | {
+                            map: {
+                                var: string;
+                            }[];
+                            var?: undefined;
+                        })[];
+                    }[];
+                    or?: undefined;
+                })[];
+                "==="?: undefined;
+                ">="?: undefined;
+                or?: undefined;
+            };
+            effect: {
+                merge: ({
+                    var: string;
+                    completions?: undefined;
+                } | {
+                    completions: {
+                        cat: ({
+                            var: string;
+                        } | {
+                            agent: {
+                                var: string;
                             };
-                            readonly proof: {
-                                readonly var: "event.proof";
+                            proof: {
+                                var: string;
                             };
-                            readonly submittedAt: {
-                                readonly var: "$timestamp";
+                            submittedAt: {
+                                var: string;
                             };
-                        }]];
-                    };
-                }];
-            };
-            readonly dependencies: readonly [];
-        }, {
-            readonly from: "ACTIVE";
-            readonly to: "COMPLETED";
-            readonly eventName: "finalize";
-            readonly guard: {
-                readonly ">=": readonly [{
-                    readonly size: {
-                        readonly var: "state.completions";
-                    };
-                }, 2];
-            };
-            readonly effect: {
-                readonly merge: readonly [{
-                    readonly var: "state";
-                }, {
-                    readonly status: "COMPLETED";
-                    readonly completedAt: {
-                        readonly var: "$timestamp";
-                    };
-                }];
-            };
-            readonly dependencies: readonly [];
-        }, {
-            readonly from: "ACTIVE";
-            readonly to: "DISPUTED";
-            readonly eventName: "dispute";
-            readonly guard: {
-                readonly or: readonly [{
-                    readonly "===": readonly [{
-                        readonly var: "event.agent";
-                    }, {
-                        readonly var: "state.proposer";
-                    }];
-                }, {
-                    readonly "===": readonly [{
-                        readonly var: "event.agent";
-                    }, {
-                        readonly var: "state.counterparty";
-                    }];
-                }];
-            };
-            readonly effect: {
-                readonly merge: readonly [{
-                    readonly var: "state";
-                }, {
-                    readonly status: "DISPUTED";
-                    readonly disputedAt: {
-                        readonly var: "$timestamp";
-                    };
-                    readonly disputeReason: {
-                        readonly var: "event.reason";
-                    };
-                    readonly disputedBy: {
-                        readonly var: "event.agent";
-                    };
-                }];
-            };
-            readonly dependencies: readonly [];
-        }, {
-            readonly from: "DISPUTED";
-            readonly to: "COMPLETED";
-            readonly eventName: "resolve";
-            readonly guard: {
-                readonly or: readonly [{
-                    readonly var: "event.judicialRuling";
-                }, {
-                    readonly and: readonly [{
-                        readonly "===": readonly [{
-                            readonly var: "event.proposerApproves";
-                        }, true];
-                    }, {
-                        readonly "===": readonly [{
-                            readonly var: "event.counterpartyApproves";
-                        }, true];
-                    }];
-                }];
-            };
-            readonly effect: {
-                readonly merge: readonly [{
-                    readonly var: "state";
-                }, {
-                    readonly status: "COMPLETED";
-                    readonly resolvedAt: {
-                        readonly var: "$timestamp";
-                    };
-                    readonly resolution: {
-                        readonly var: "event.resolution";
-                    };
-                    readonly rulingId: {
-                        readonly var: "event.rulingId";
-                    };
-                }];
-            };
-            readonly dependencies: readonly [];
-        }, {
-            readonly from: "ACTIVE";
-            readonly to: "CANCELLED";
-            readonly eventName: "cancel";
-            readonly guard: {
-                readonly or: readonly [{
-                    readonly "===": readonly [{
-                        readonly var: "event.agent";
-                    }, {
-                        readonly var: "state.proposer";
-                    }];
-                }, {
-                    readonly "===": readonly [{
-                        readonly var: "event.agent";
-                    }, {
-                        readonly var: "state.counterparty";
-                    }];
-                }];
-            };
-            readonly effect: {
-                readonly merge: readonly [{
-                    readonly var: "state";
-                }, {
-                    readonly status: "CANCELLED";
-                    readonly cancelledAt: {
-                        readonly var: "$timestamp";
-                    };
-                }];
-            };
-            readonly dependencies: readonly [];
-        }];
+                        }[])[];
+                    };
+                    var?: undefined;
+                })[];
+            };
+            dependencies: never[];
+        } | {
+            from: "ACTIVE";
+            to: "COMPLETED";
+            eventName: "finalize";
+            guard: {
+                ">=": (number | {
+                    size: {
+                        var: string;
+                    };
+                })[];
+                "==="?: undefined;
+                and?: undefined;
+                or?: undefined;
+            };
+            effect: {
+                merge: ({
+                    var: string;
+                    status?: undefined;
+                    completedAt?: undefined;
+                } | {
+                    status: string;
+                    completedAt: {
+                        var: string;
+                    };
+                    var?: undefined;
+                })[];
+            };
+            dependencies: never[];
+        } | {
+            from: "ACTIVE";
+            to: "DISPUTED";
+            eventName: "dispute";
+            guard: {
+                or: {
+                    "===": {
+                        var: string;
+                    }[];
+                }[];
+                "==="?: undefined;
+                and?: undefined;
+                ">="?: undefined;
+            };
+            effect: {
+                merge: ({
+                    var: string;
+                    status?: undefined;
+                    disputedAt?: undefined;
+                    disputeReason?: undefined;
+                    disputedBy?: undefined;
+                } | {
+                    status: string;
+                    disputedAt: {
+                        var: string;
+                    };
+                    disputeReason: {
+                        var: string;
+                    };
+                    disputedBy: {
+                        var: string;
+                    };
+                    var?: undefined;
+                })[];
+            };
+            dependencies: never[];
+        } | {
+            from: "DISPUTED";
+            to: "COMPLETED";
+            eventName: "resolve";
+            guard: {
+                or: ({
+                    var: string;
+                    and?: undefined;
+                } | {
+                    and: {
+                        "===": (boolean | {
+                            var: string;
+                        })[];
+                    }[];
+                    var?: undefined;
+                })[];
+                "==="?: undefined;
+                and?: undefined;
+                ">="?: undefined;
+            };
+            effect: {
+                merge: ({
+                    var: string;
+                    status?: undefined;
+                    resolvedAt?: undefined;
+                    resolution?: undefined;
+                    rulingId?: undefined;
+                } | {
+                    status: string;
+                    resolvedAt: {
+                        var: string;
+                    };
+                    resolution: {
+                        var: string;
+                    };
+                    rulingId: {
+                        var: string;
+                    };
+                    var?: undefined;
+                })[];
+            };
+            dependencies: never[];
+        } | {
+            from: "ACTIVE";
+            to: "CANCELLED";
+            eventName: "cancel";
+            guard: {
+                or: {
+                    "===": {
+                        var: string;
+                    }[];
+                }[];
+                "==="?: undefined;
+                and?: undefined;
+                ">="?: undefined;
+            };
+            effect: {
+                merge: ({
+                    var: string;
+                    status?: undefined;
+                    cancelledAt?: undefined;
+                } | {
+                    status: string;
+                    cancelledAt: {
+                        var: string;
+                    };
+                    var?: undefined;
+                })[];
+            };
+            dependencies: never[];
+        })[];
     };
     readonly escrow: {
-        readonly metadata: {
-            readonly name: "ContractEscrow";
-            readonly description: "Asset custody with conditional release, dispute resolution, and split payments";
-            readonly version: "1.0.0";
-            readonly app: "contracts";
-            readonly type: "escrow";
-            readonly crossReferences: {
-                readonly contractId: "Links to Contract SM that created this escrow";
-                readonly marketId: "Links to Market SM for market-based escrow";
-                readonly insuranceId: "Links to Insurance SM for protected escrow";
-                readonly arbitrationPoolId: "Links to ArbitrationPool for dispute resolution";
-                readonly treasuryId: "Links to Treasury for fee collection";
+        metadata: {
+            name: string;
+            app: string;
+            type: string;
+            version: string;
+            description: string;
+            crossReferences: {
+                contractId: {
+                    machine: string;
+                    field: string;
+                    description: string;
+                };
+                marketId: {
+                    machine: string;
+                    field: string;
+                    description: string;
+                };
+                insuranceId: {
+                    machine: string;
+                    field: string;
+                    description: string;
+                };
+                arbitrationPoolId: {
+                    machine: string;
+                    field: string;
+                    description: string;
+                };
+                treasuryId: {
+                    machine: string;
+                    field: string;
+                    description: string;
+                };
             };
         };
-        readonly createSchema: {
-            readonly required: readonly ["depositor", "beneficiary", "requiredAmount"];
-            readonly properties: {
-                readonly depositor: {
-                    readonly type: "address";
-                    readonly description: "DAG address of the depositor";
+        createSchema: {
+            required: readonly ["depositor", "beneficiary", "requiredAmount"];
+            properties: {
+                depositor: {
+                    type: "address";
+                    description: string;
+                };
+                beneficiary: {
+                    type: "address";
+                    description: string;
                 };
-                readonly beneficiary: {
-                    readonly type: "address";
-                    readonly description: "DAG address of the beneficiary";
+                requiredAmount: {
+                    type: "number";
+                    minimum: number;
+                    description: string;
                 };
-                readonly requiredAmount: {
-                    readonly type: "number";
-                    readonly minimum: 0;
-                    readonly description: "Required escrow amount";
+                releaseWindowMs: {
+                    type: "integer";
+                    description: string;
+                    nullable: true;
+                };
+                expiresAt: {
+                    type: "integer";
+                    description: string;
+                    nullable: true;
+                };
+                autoActivate: {
+                    type: "boolean";
+                    description: string;
+                    nullable: true;
                 };
             };
         };
-        readonly stateSchema: {
-            readonly properties: {
-                readonly balance: {
-                    readonly type: "number";
+        stateSchema: {
+            properties: {
+                depositor: {
+                    type: "address";
+                };
+                beneficiary: {
+                    type: "address";
+                };
+                requiredAmount: {
+                    type: "number";
+                };
+                balance: {
+                    type: "number";
+                };
+                fundedAt: {
+                    type: "integer";
+                    nullable: true;
+                };
+                activatedAt: {
+                    type: "integer";
+                    nullable: true;
                 };
-                readonly releaseRequest: {
-                    readonly type: "object";
+                releaseRequest: {
+                    type: "object";
+                    nullable: true;
+                };
+                releaseDeadline: {
+                    type: "integer";
+                    nullable: true;
+                };
+                releasedAt: {
+                    type: "integer";
+                    nullable: true;
+                };
+                releasedTo: {
+                    type: "address";
+                    nullable: true;
+                };
+                disputedAt: {
+                    type: "integer";
+                    nullable: true;
+                };
+                refundedAt: {
+                    type: "integer";
+                    nullable: true;
+                };
+                splits: {
+                    type: "array";
+                    nullable: true;
+                };
+                rulingId: {
+                    type: "string";
+                    nullable: true;
+                };
+                releaseWindowMs: {
+                    type: "integer";
+                    nullable: true;
+                };
+                expiresAt: {
+                    type: "integer";
+                    nullable: true;
+                };
+                autoActivate: {
+                    type: "boolean";
+                    nullable: true;
                 };
             };
         };
-        readonly eventSchemas: {
-            readonly deposit: {};
-            readonly activate: {};
-            readonly request_release: {};
-            readonly approve_release: {};
-            readonly dispute: {};
-            readonly ruling: {};
-            readonly refund: {};
+        eventSchemas: {
+            deposit: {
+                properties: {
+                    amount: {
+                        type: "number";
+                    };
+                };
+            };
+            activate: {};
+            request_release: {
+                properties: {
+                    amount: {
+                        type: "number";
+                    };
+                    reason: {
+                        type: "string";
+                        nullable: true;
+                    };
+                };
+            };
+            approve_release: {};
+            dispute: {};
+            ruling: {
+                properties: {
+                    judicialRuling: {
+                        type: "boolean";
+                    };
+                    splits: {
+                        type: "array";
+                    };
+                    rulingId: {
+                        type: "string";
+                    };
+                };
+            };
+            refund: {
+                properties: {
+                    mutualConsent: {
+                        type: "boolean";
+                        nullable: true;
+                    };
+                };
+            };
+            cancel: {};
         };
-        readonly states: {
-            readonly CREATED: {
-                readonly id: "CREATED";
-                readonly isFinal: false;
-                readonly metadata: null;
-            };
-            readonly FUNDED: {
-                readonly id: "FUNDED";
-                readonly isFinal: false;
-                readonly metadata: null;
-            };
-            readonly ACTIVE: {
-                readonly id: "ACTIVE";
-                readonly isFinal: false;
-                readonly metadata: null;
-            };
-            readonly RELEASING: {
-                readonly id: "RELEASING";
-                readonly isFinal: false;
-                readonly metadata: null;
-            };
-            readonly DISPUTED: {
-                readonly id: "DISPUTED";
-                readonly isFinal: false;
-                readonly metadata: null;
-            };
-            readonly RELEASED: {
-                readonly id: "RELEASED";
-                readonly isFinal: true;
-                readonly metadata: null;
-            };
-            readonly REFUNDED: {
-                readonly id: "REFUNDED";
-                readonly isFinal: true;
-                readonly metadata: null;
-            };
-            readonly SPLIT: {
-                readonly id: "SPLIT";
-                readonly isFinal: true;
-                readonly metadata: null;
+        states: {
+            CREATED: {
+                id: string;
+                isFinal: false;
+                metadata: null;
+            };
+            FUNDED: {
+                id: string;
+                isFinal: false;
+                metadata: null;
+            };
+            ACTIVE: {
+                id: string;
+                isFinal: false;
+                metadata: null;
+            };
+            RELEASING: {
+                id: string;
+                isFinal: false;
+                metadata: null;
+            };
+            DISPUTED: {
+                id: string;
+                isFinal: false;
+                metadata: null;
+            };
+            RELEASED: {
+                id: string;
+                isFinal: true;
+                metadata: null;
+            };
+            REFUNDED: {
+                id: string;
+                isFinal: true;
+                metadata: null;
+            };
+            SPLIT: {
+                id: string;
+                isFinal: true;
+                metadata: null;
             };
         };
-        readonly initialState: "CREATED";
-        readonly transitions: readonly [{
-            readonly from: "CREATED";
-            readonly to: "FUNDED";
-            readonly eventName: "deposit";
-            readonly guard: {
-                readonly and: readonly [{
-                    readonly "===": readonly [{
-                        readonly var: "event.agent";
-                    }, {
-                        readonly var: "state.depositor";
-                    }];
-                }, {
-                    readonly ">=": readonly [{
-                        readonly var: "event.amount";
-                    }, {
-                        readonly var: "state.requiredAmount";
-                    }];
-                }];
-            };
-            readonly effect: {
-                readonly merge: readonly [{
-                    readonly var: "state";
-                }, {
-                    readonly balance: {
-                        readonly var: "event.amount";
-                    };
-                    readonly fundedAt: {
-                        readonly var: "$timestamp";
-                    };
-                }];
-            };
-            readonly dependencies: readonly [];
-        }, {
-            readonly from: "FUNDED";
-            readonly to: "ACTIVE";
-            readonly eventName: "activate";
-            readonly guard: {
-                readonly or: readonly [{
-                    readonly "===": readonly [{
-                        readonly var: "event.agent";
-                    }, {
-                        readonly var: "state.beneficiary";
-                    }];
-                }, {
-                    readonly var: "state.autoActivate";
-                }];
-            };
-            readonly effect: {
-                readonly merge: readonly [{
-                    readonly var: "state";
-                }, {
-                    readonly activatedAt: {
-                        readonly var: "$timestamp";
-                    };
-                }];
-            };
-            readonly dependencies: readonly [];
-        }, {
-            readonly from: "ACTIVE";
-            readonly to: "RELEASING";
-            readonly eventName: "request_release";
-            readonly guard: {
-                readonly "===": readonly [{
-                    readonly var: "event.agent";
-                }, {
-                    readonly var: "state.beneficiary";
-                }];
-            };
-            readonly effect: {
-                readonly merge: readonly [{
-                    readonly var: "state";
-                }, {
-                    readonly releaseRequest: {
-                        readonly requestedBy: {
-                            readonly var: "event.agent";
+        initialState: "CREATED";
+        transitions: ({
+            from: "CREATED";
+            to: "FUNDED";
+            eventName: "deposit";
+            guard: {
+                and: ({
+                    "===": {
+                        var: string;
+                    }[];
+                    ">="?: undefined;
+                } | {
+                    ">=": {
+                        var: string;
+                    }[];
+                    "==="?: undefined;
+                })[];
+                or?: undefined;
+                "==="?: undefined;
+                var?: undefined;
+            };
+            effect: {
+                merge: ({
+                    var: string;
+                    balance?: undefined;
+                    fundedAt?: undefined;
+                } | {
+                    balance: {
+                        var: string;
+                    };
+                    fundedAt: {
+                        var: string;
+                    };
+                    var?: undefined;
+                })[];
+            };
+            dependencies: never[];
+            spawns?: undefined;
+        } | {
+            from: "FUNDED";
+            to: "ACTIVE";
+            eventName: "activate";
+            guard: {
+                or: ({
+                    "===": {
+                        var: string;
+                    }[];
+                    var?: undefined;
+                } | {
+                    var: string;
+                    "==="?: undefined;
+                })[];
+                and?: undefined;
+                "==="?: undefined;
+                var?: undefined;
+            };
+            effect: {
+                merge: ({
+                    var: string;
+                    activatedAt?: undefined;
+                } | {
+                    activatedAt: {
+                        var: string;
+                    };
+                    var?: undefined;
+                })[];
+            };
+            dependencies: never[];
+            spawns?: undefined;
+        } | {
+            from: "ACTIVE";
+            to: "RELEASING";
+            eventName: "request_release";
+            guard: {
+                "===": {
+                    var: string;
+                }[];
+                and?: undefined;
+                or?: undefined;
+                var?: undefined;
+            };
+            effect: {
+                merge: ({
+                    var: string;
+                    releaseRequest?: undefined;
+                    releaseDeadline?: undefined;
+                } | {
+                    releaseRequest: {
+                        requestedBy: {
+                            var: string;
                         };
-                        readonly amount: {
-                            readonly var: "event.amount";
+                        amount: {
+                            var: string;
                         };
-                        readonly reason: {
-                            readonly var: "event.reason";
+                        reason: {
+                            var: string;
                         };
-                        readonly requestedAt: {
-                            readonly var: "$timestamp";
+                        requestedAt: {
+                            var: string;
                         };
                     };
-                    readonly releaseDeadline: {
-                        readonly "+": readonly [{
-                            readonly var: "$timestamp";
-                        }, {
-                            readonly var: "state.releaseWindowMs";
-                        }];
-                    };
-                }];
-            };
-            readonly dependencies: readonly [];
-        }, {
-            readonly from: "RELEASING";
-            readonly to: "RELEASED";
-            readonly eventName: "approve_release";
-            readonly guard: {
-                readonly or: readonly [{
-                    readonly "===": readonly [{
-                        readonly var: "event.agent";
-                    }, {
-                        readonly var: "state.depositor";
-                    }];
-                }, {
-                    readonly ">=": readonly [{
-                        readonly var: "$timestamp";
-                    }, {
-                        readonly var: "state.releaseDeadline";
-                    }];
-                }];
-            };
-            readonly effect: {
-                readonly merge: readonly [{
-                    readonly var: "state";
-                }, {
-                    readonly releasedAt: {
-                        readonly var: "$timestamp";
-                    };
-                    readonly releasedTo: {
-                        readonly var: "state.beneficiary";
-                    };
-                }];
-            };
-            readonly dependencies: readonly [];
-        }, {
-            readonly from: "RELEASING";
-            readonly to: "DISPUTED";
-            readonly eventName: "dispute";
-            readonly guard: {
-                readonly and: readonly [{
-                    readonly "===": readonly [{
-                        readonly var: "event.agent";
-                    }, {
-                        readonly var: "state.depositor";
-                    }];
-                }, {
-                    readonly "<": readonly [{
-                        readonly var: "$timestamp";
-                    }, {
-                        readonly var: "state.releaseDeadline";
-                    }];
-                }];
-            };
-            readonly effect: {
-                readonly merge: readonly [{
-                    readonly var: "state";
-                }, {
-                    readonly disputedAt: {
-                        readonly var: "$timestamp";
-                    };
-                }];
-            };
-            readonly spawns: {
-                readonly sm: "Judiciary";
-                readonly initialData: {
-                    readonly caseType: "escrow_dispute";
-                    readonly plaintiff: {
-                        readonly var: "state.depositor";
-                    };
-                    readonly defendant: {
-                        readonly var: "state.beneficiary";
-                    };
-                    readonly claim: {
-                        readonly escrowId: {
-                            readonly var: "fiberId";
+                    releaseDeadline: {
+                        "+": {
+                            var: string;
+                        }[];
+                    };
+                    var?: undefined;
+                })[];
+            };
+            dependencies: never[];
+            spawns?: undefined;
+        } | {
+            from: "RELEASING";
+            to: "RELEASED";
+            eventName: "approve_release";
+            guard: {
+                or: ({
+                    "===": {
+                        var: string;
+                    }[];
+                    ">="?: undefined;
+                } | {
+                    ">=": {
+                        var: string;
+                    }[];
+                    "==="?: undefined;
+                })[];
+                and?: undefined;
+                "==="?: undefined;
+                var?: undefined;
+            };
+            effect: {
+                merge: ({
+                    var: string;
+                    releasedAt?: undefined;
+                    releasedTo?: undefined;
+                } | {
+                    releasedAt: {
+                        var: string;
+                    };
+                    releasedTo: {
+                        var: string;
+                    };
+                    var?: undefined;
+                })[];
+            };
+            dependencies: never[];
+            spawns?: undefined;
+        } | {
+            from: "RELEASING";
+            to: "DISPUTED";
+            eventName: "dispute";
+            guard: {
+                and: ({
+                    "===": {
+                        var: string;
+                    }[];
+                    "<"?: undefined;
+                } | {
+                    "<": {
+                        var: string;
+                    }[];
+                    "==="?: undefined;
+                })[];
+                or?: undefined;
+                "==="?: undefined;
+                var?: undefined;
+            };
+            effect: {
+                merge: ({
+                    var: string;
+                    disputedAt?: undefined;
+                } | {
+                    disputedAt: {
+                        var: string;
+                    };
+                    var?: undefined;
+                })[];
+            };
+            spawns: {
+                sm: string;
+                initialData: {
+                    caseType: string;
+                    plaintiff: {
+                        var: string;
+                    };
+                    defendant: {
+                        var: string;
+                    };
+                    claim: {
+                        escrowId: {
+                            var: string;
                         };
-                        readonly amount: {
-                            readonly var: "state.balance";
+                        amount: {
+                            var: string;
                         };
                     };
                 };
             };
-            readonly dependencies: readonly [];
-        }, {
-            readonly from: "DISPUTED";
-            readonly to: "SPLIT";
-            readonly eventName: "ruling";
-            readonly guard: {
-                readonly var: "event.judicialRuling";
-            };
-            readonly effect: {
-                readonly merge: readonly [{
-                    readonly var: "state";
-                }, {
-                    readonly splits: {
-                        readonly var: "event.splits";
-                    };
-                    readonly rulingId: {
-                        readonly var: "event.rulingId";
-                    };
-                }];
-            };
-            readonly dependencies: readonly [];
-        }, {
-            readonly from: "ACTIVE";
-            readonly to: "REFUNDED";
-            readonly eventName: "refund";
-            readonly guard: {
-                readonly or: readonly [{
-                    readonly var: "event.mutualConsent";
-                }, {
-                    readonly ">=": readonly [{
-                        readonly var: "$timestamp";
-                    }, {
-                        readonly var: "state.expiresAt";
-                    }];
-                }];
-            };
-            readonly effect: {
-                readonly merge: readonly [{
-                    readonly var: "state";
-                }, {
-                    readonly refundedAt: {
-                        readonly var: "$timestamp";
-                    };
-                }];
-            };
-            readonly dependencies: readonly [];
-        }, {
-            readonly from: "CREATED";
-            readonly to: "REFUNDED";
-            readonly eventName: "cancel";
-            readonly guard: {
-                readonly "===": readonly [{
-                    readonly var: "event.agent";
-                }, {
-                    readonly var: "state.depositor";
-                }];
-            };
-            readonly effect: {
-                readonly merge: readonly [{
-                    readonly var: "state";
-                }, {
-                    readonly refundedAt: {
-                        readonly var: "$timestamp";
-                    };
-                }];
-            };
-            readonly dependencies: readonly [];
-        }];
+            dependencies: never[];
+        } | {
+            from: "DISPUTED";
+            to: "SPLIT";
+            eventName: "ruling";
+            guard: {
+                var: string;
+                and?: undefined;
+                or?: undefined;
+                "==="?: undefined;
+            };
+            effect: {
+                merge: ({
+                    var: string;
+                    splits?: undefined;
+                    rulingId?: undefined;
+                } | {
+                    splits: {
+                        var: string;
+                    };
+                    rulingId: {
+                        var: string;
+                    };
+                    var?: undefined;
+                })[];
+            };
+            dependencies: never[];
+            spawns?: undefined;
+        } | {
+            from: "ACTIVE";
+            to: "REFUNDED";
+            eventName: "refund";
+            guard: {
+                or: ({
+                    var: string;
+                    ">="?: undefined;
+                } | {
+                    ">=": {
+                        var: string;
+                    }[];
+                    var?: undefined;
+                })[];
+                and?: undefined;
+                "==="?: undefined;
+                var?: undefined;
+            };
+            effect: {
+                merge: ({
+                    var: string;
+                    refundedAt?: undefined;
+                } | {
+                    refundedAt: {
+                        var: string;
+                    };
+                    var?: undefined;
+                })[];
+            };
+            dependencies: never[];
+            spawns?: undefined;
+        } | {
+            from: "CREATED";
+            to: "REFUNDED";
+            eventName: "cancel";
+            guard: {
+                "===": {
+                    var: string;
+                }[];
+                and?: undefined;
+                or?: undefined;
+                var?: undefined;
+            };
+            effect: {
+                merge: ({
+                    var: string;
+                    refundedAt?: undefined;
+                } | {
+                    refundedAt: {
+                        var: string;
+                    };
+                    var?: undefined;
+                })[];
+            };
+            dependencies: never[];
+            spawns?: undefined;
+        })[];
     };
 };
 export type ContractType = keyof typeof CONTRACTS_DEFINITIONS;
@@ -826,6 +1141,6 @@ export type ContractType = keyof typeof CONTRACTS_DEFINITIONS;
  * Get a contract state machine definition by type.
  * @param type - 'universal' | 'agreement' | 'escrow' (default: 'agreement')
  */
-export declare function getContractDefinition(type?: ContractType): unknown;
+export declare function getContractDefinition(type?: ContractType): FiberAppDefinition;
 /** @deprecated Use getContractDefinition('escrow') */
-export declare function getEscrowDefinition(): unknown;
+export declare function getEscrowDefinition(): FiberAppDefinition;