@ottochain/sdk 0.2.0

package/dist/types/generated/google/protobuf/struct.d.ts

@@ -0,0 +1,134 @@
+import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire";
+export declare const protobufPackage = "google.protobuf";
+/**
+ * `NullValue` is a singleton enumeration to represent the null value for the
+ * `Value` type union.
+ *
+ * The JSON representation for `NullValue` is JSON `null`.
+ */
+export declare enum NullValue {
+    /** NULL_VALUE - Null value. */
+    NULL_VALUE = "NULL_VALUE",
+    UNRECOGNIZED = "UNRECOGNIZED"
+}
+export declare function nullValueFromJSON(object: any): NullValue;
+export declare function nullValueToJSON(object: NullValue): string;
+export declare function nullValueToNumber(object: NullValue): number;
+/**
+ * `Struct` represents a structured data value, consisting of fields
+ * which map to dynamically typed values. In some languages, `Struct`
+ * might be supported by a native representation. For example, in
+ * scripting languages like JS a struct is represented as an
+ * object. The details of that representation are described together
+ * with the proto support for the language.
+ *
+ * The JSON representation for `Struct` is JSON object.
+ */
+export interface Struct {
+    /** Unordered map of dynamically typed values. */
+    fields: {
+        [key: string]: any | undefined;
+    };
+}
+export interface Struct_FieldsEntry {
+    key: string;
+    value?: any | undefined;
+}
+/**
+ * `Value` represents a dynamically typed value which can be either
+ * null, a number, a string, a boolean, a recursive struct value, or a
+ * list of values. A producer of value is expected to set one of these
+ * variants. Absence of any variant indicates an error.
+ *
+ * The JSON representation for `Value` is JSON value.
+ */
+export interface Value {
+    /** The kind of value. */
+    kind?: //
+    /** Represents a null value. */
+    {
+        $case: "nullValue";
+        nullValue: NullValue;
+    } | //
+    /** Represents a double value. */
+    {
+        $case: "numberValue";
+        numberValue: number;
+    } | //
+    /** Represents a string value. */
+    {
+        $case: "stringValue";
+        stringValue: string;
+    } | //
+    /** Represents a boolean value. */
+    {
+        $case: "boolValue";
+        boolValue: boolean;
+    } | //
+    /** Represents a structured value. */
+    {
+        $case: "structValue";
+        structValue: {
+            [key: string]: any;
+        } | undefined;
+    } | //
+    /** Represents a repeated `Value`. */
+    {
+        $case: "listValue";
+        listValue: Array<any> | undefined;
+    } | undefined;
+}
+/**
+ * `ListValue` is a wrapper around a repeated field of values.
+ *
+ * The JSON representation for `ListValue` is JSON array.
+ */
+export interface ListValue {
+    /** Repeated field of dynamically typed values. */
+    values: any[];
+}
+export declare const Struct: MessageFns<Struct> & StructWrapperFns;
+export declare const Struct_FieldsEntry: MessageFns<Struct_FieldsEntry>;
+export declare const Value: MessageFns<Value> & AnyValueWrapperFns;
+export declare const ListValue: MessageFns<ListValue> & ListValueWrapperFns;
+type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;
+export type DeepPartial<T> = T extends Builtin ? T : T extends globalThis.Array<infer U> ? globalThis.Array<DeepPartial<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>> : T extends {
+    $case: string;
+} ? {
+    [K in keyof Omit<T, "$case">]?: DeepPartial<T[K]>;
+} & {
+    $case: T["$case"];
+} : T extends {} ? {
+    [K in keyof T]?: DeepPartial<T[K]>;
+} : Partial<T>;
+type KeysOfUnion<T> = T extends T ? keyof T : never;
+export type Exact<P, I extends P> = P extends Builtin ? P : P & {
+    [K in keyof P]: Exact<P[K], I[K]>;
+} & {
+    [K in Exclude<keyof I, KeysOfUnion<P>>]: never;
+};
+export interface MessageFns<T> {
+    encode(message: T, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): T;
+    fromJSON(object: any): T;
+    toJSON(message: T): unknown;
+    create<I extends Exact<DeepPartial<T>, I>>(base?: I): T;
+    fromPartial<I extends Exact<DeepPartial<T>, I>>(object: I): T;
+}
+export interface StructWrapperFns {
+    wrap(object: {
+        [key: string]: any;
+    } | undefined): Struct;
+    unwrap(message: Struct): {
+        [key: string]: any;
+    };
+}
+export interface AnyValueWrapperFns {
+    wrap(value: any): Value;
+    unwrap(message: any): string | number | boolean | Object | null | Array<any> | undefined;
+}
+export interface ListValueWrapperFns {
+    wrap(array: Array<any> | undefined): ListValue;
+    unwrap(message: ListValue): Array<any>;
+}
+export {};

package/dist/types/generated/google/protobuf/timestamp.d.ts

@@ -0,0 +1,134 @@
+import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire";
+export declare const protobufPackage = "google.protobuf";
+/**
+ * A Timestamp represents a point in time independent of any time zone or local
+ * calendar, encoded as a count of seconds and fractions of seconds at
+ * nanosecond resolution. The count is relative to an epoch at UTC midnight on
+ * January 1, 1970, in the proleptic Gregorian calendar which extends the
+ * Gregorian calendar backwards to year one.
+ *
+ * All minutes are 60 seconds long. Leap seconds are "smeared" so that no leap
+ * second table is needed for interpretation, using a [24-hour linear
+ * smear](https://developers.google.com/time/smear).
+ *
+ * The range is from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59.999999999Z. By
+ * restricting to that range, we ensure that we can convert to and from [RFC
+ * 3339](https://www.ietf.org/rfc/rfc3339.txt) date strings.
+ *
+ * # Examples
+ *
+ * Example 1: Compute Timestamp from POSIX `time()`.
+ *
+ *     Timestamp timestamp;
+ *     timestamp.set_seconds(time(NULL));
+ *     timestamp.set_nanos(0);
+ *
+ * Example 2: Compute Timestamp from POSIX `gettimeofday()`.
+ *
+ *     struct timeval tv;
+ *     gettimeofday(&tv, NULL);
+ *
+ *     Timestamp timestamp;
+ *     timestamp.set_seconds(tv.tv_sec);
+ *     timestamp.set_nanos(tv.tv_usec * 1000);
+ *
+ * Example 3: Compute Timestamp from Win32 `GetSystemTimeAsFileTime()`.
+ *
+ *     FILETIME ft;
+ *     GetSystemTimeAsFileTime(&ft);
+ *     UINT64 ticks = (((UINT64)ft.dwHighDateTime) << 32) | ft.dwLowDateTime;
+ *
+ *     // A Windows tick is 100 nanoseconds. Windows epoch 1601-01-01T00:00:00Z
+ *     // is 11644473600 seconds before Unix epoch 1970-01-01T00:00:00Z.
+ *     Timestamp timestamp;
+ *     timestamp.set_seconds((INT64) ((ticks / 10000000) - 11644473600LL));
+ *     timestamp.set_nanos((INT32) ((ticks % 10000000) * 100));
+ *
+ * Example 4: Compute Timestamp from Java `System.currentTimeMillis()`.
+ *
+ *     long millis = System.currentTimeMillis();
+ *
+ *     Timestamp timestamp = Timestamp.newBuilder().setSeconds(millis / 1000)
+ *         .setNanos((int) ((millis % 1000) * 1000000)).build();
+ *
+ * Example 5: Compute Timestamp from Java `Instant.now()`.
+ *
+ *     Instant now = Instant.now();
+ *
+ *     Timestamp timestamp =
+ *         Timestamp.newBuilder().setSeconds(now.getEpochSecond())
+ *             .setNanos(now.getNano()).build();
+ *
+ * Example 6: Compute Timestamp from current time in Python.
+ *
+ *     timestamp = Timestamp()
+ *     timestamp.GetCurrentTime()
+ *
+ * # JSON Mapping
+ *
+ * In JSON format, the Timestamp type is encoded as a string in the
+ * [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) format. That is, the
+ * format is "{year}-{month}-{day}T{hour}:{min}:{sec}[.{frac_sec}]Z"
+ * where {year} is always expressed using four digits while {month}, {day},
+ * {hour}, {min}, and {sec} are zero-padded to two digits each. The fractional
+ * seconds, which can go up to 9 digits (i.e. up to 1 nanosecond resolution),
+ * are optional. The "Z" suffix indicates the timezone ("UTC"); the timezone
+ * is required. A proto3 JSON serializer should always use UTC (as indicated by
+ * "Z") when printing the Timestamp type and a proto3 JSON parser should be
+ * able to accept both UTC and other timezones (as indicated by an offset).
+ *
+ * For example, "2017-01-15T01:30:15.01Z" encodes 15.01 seconds past
+ * 01:30 UTC on January 15, 2017.
+ *
+ * In JavaScript, one can convert a Date object to this format using the
+ * standard
+ * [toISOString()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toISOString)
+ * method. In Python, a standard `datetime.datetime` object can be converted
+ * to this format using
+ * [`strftime`](https://docs.python.org/2/library/time.html#time.strftime) with
+ * the time format spec '%Y-%m-%dT%H:%M:%S.%fZ'. Likewise, in Java, one can use
+ * the Joda Time's [`ISODateTimeFormat.dateTime()`](
+ * http://joda-time.sourceforge.net/apidocs/org/joda/time/format/ISODateTimeFormat.html#dateTime()
+ * ) to obtain a formatter capable of generating timestamps in this format.
+ */
+export interface Timestamp {
+    /**
+     * Represents seconds of UTC time since Unix epoch
+     * 1970-01-01T00:00:00Z. Must be from 0001-01-01T00:00:00Z to
+     * 9999-12-31T23:59:59Z inclusive.
+     */
+    seconds: number;
+    /**
+     * Non-negative fractions of a second at nanosecond resolution. Negative
+     * second values with fractions must still have non-negative nanos values
+     * that count forward in time. Must be from 0 to 999,999,999
+     * inclusive.
+     */
+    nanos: number;
+}
+export declare const Timestamp: MessageFns<Timestamp>;
+type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;
+export type DeepPartial<T> = T extends Builtin ? T : T extends globalThis.Array<infer U> ? globalThis.Array<DeepPartial<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>> : T extends {
+    $case: string;
+} ? {
+    [K in keyof Omit<T, "$case">]?: DeepPartial<T[K]>;
+} & {
+    $case: T["$case"];
+} : T extends {} ? {
+    [K in keyof T]?: DeepPartial<T[K]>;
+} : Partial<T>;
+type KeysOfUnion<T> = T extends T ? keyof T : never;
+export type Exact<P, I extends P> = P extends Builtin ? P : P & {
+    [K in keyof P]: Exact<P[K], I[K]>;
+} & {
+    [K in Exclude<keyof I, KeysOfUnion<P>>]: never;
+};
+export interface MessageFns<T> {
+    encode(message: T, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): T;
+    fromJSON(object: any): T;
+    toJSON(message: T): unknown;
+    create<I extends Exact<DeepPartial<T>, I>>(base?: I): T;
+    fromPartial<I extends Exact<DeepPartial<T>, I>>(object: I): T;
+}
+export {};

package/dist/types/generated/index.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Generated Protobuf Types
+ *
+ * Auto-generated from proto/ definitions using ts-proto.
+ * DO NOT EDIT - regenerate with `pnpm run generate`
+ *
+ * @packageDocumentation
+ */
+export { FiberStatus, AccessControlPolicy, PublicAccess, WhitelistAccess, FiberOwnedAccess, StateMachineDefinition, EmittedEvent, EventReceipt, ScriptInvocation, FiberLogEntry, } from './ottochain/v1/fiber.js';
+export { CreateStateMachine, TransitionStateMachine, ArchiveStateMachine, CreateScript, InvokeScript, OttochainMessage, } from './ottochain/v1/messages.js';
+export { StateMachineFiberRecord, ScriptFiberRecord, FiberCommit, OnChainState, CalculatedState, } from './ottochain/v1/records.js';
+export { AgentState, Platform, PlatformLink, AgentIdentity, AgentIdentityDefinition, } from './ottochain/apps/identity/v1/agent.js';
+export { AttestationType, ReputationDelta, Attestation, VouchRequest, ChallengeRequest, ReputationConfig, } from './ottochain/apps/identity/v1/attestation.js';
+export { ContractState, Contract, ProposeContractRequest, AcceptContractRequest, CompleteContractRequest, RejectContractRequest, DisputeContractRequest, ContractDefinition, } from './ottochain/apps/contracts/v1/contract.js';
+export { MarketType, MarketState, Commitment, Resolution, Market, CreateMarketRequest, CommitToMarketRequest, SubmitResolutionRequest, CancelMarketRequest, MarketDefinition, } from './ottochain/apps/markets/v1/market.js';
+export { OracleState, OracleReputation, SlashingEvent, Oracle, RegisterOracleRequest, ActivateOracleRequest, AddStakeRequest, WithdrawStakeRequest, SlashOracleRequest, WithdrawOracleRequest, OracleDefinition, } from './ottochain/apps/oracles/v1/oracle.js';
+export { DAOType, DAOStatus, ProposalStatus, VoteChoice, DAOMetadata, Proposal, Vote, VoteTally, SingleOwnerDAO, SingleOwnerAction, OwnershipTransfer, MultisigDAO, MultisigAction, TokenDAO, TokenProposalResult, ThresholdDAO, ThresholdVotes, ThresholdHistoryEntry, CreateDAORequest, ProposeRequest, VoteRequest, ExecuteRequest, } from './ottochain/apps/governance/v1/governance.js';
+export { EntityType, EntityState, DirectorStatus, OfficerStatus, BoardMeetingType, ResolutionStatus, Jurisdiction, ShareClass, CorporateEntity, RegisteredAgent, Incorporator, ShareStructure, CorporateBoard, Director, SeatInfo, QuorumRules, BoardMeeting, MeetingAttendee, CorporateOfficers, Officer, OfficerAction, CorporateShareholders, Shareholder, ShareHolding, CorporateResolution, ResolutionVote, CorporateSecurities, SecurityIssuance, SecurityTransfer, CorporateCompliance, FilingRecord, ComplianceRequirement, CreateEntityRequest, AppointDirectorRequest, IssueSharesRequest, ProposeResolutionRequest, } from './ottochain/apps/corporate/v1/corporate.js';

package/dist/types/generated/ottochain/apps/contracts/v1/contract.d.ts

@@ -0,0 +1,112 @@
+import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire";
+export declare const protobufPackage = "ottochain.apps.contracts.v1";
+/** Contract lifecycle states */
+export declare enum ContractState {
+    CONTRACT_STATE_UNSPECIFIED = "CONTRACT_STATE_UNSPECIFIED",
+    /** CONTRACT_STATE_PROPOSED - Awaiting counterparty acceptance */
+    CONTRACT_STATE_PROPOSED = "CONTRACT_STATE_PROPOSED",
+    /** CONTRACT_STATE_ACTIVE - Both parties agreed, in progress */
+    CONTRACT_STATE_ACTIVE = "CONTRACT_STATE_ACTIVE",
+    /** CONTRACT_STATE_COMPLETED - Successfully fulfilled (terminal) */
+    CONTRACT_STATE_COMPLETED = "CONTRACT_STATE_COMPLETED",
+    /** CONTRACT_STATE_REJECTED - Counterparty declined (terminal) */
+    CONTRACT_STATE_REJECTED = "CONTRACT_STATE_REJECTED",
+    /** CONTRACT_STATE_DISPUTED - Under dispute resolution */
+    CONTRACT_STATE_DISPUTED = "CONTRACT_STATE_DISPUTED",
+    /** CONTRACT_STATE_CANCELLED - Cancelled by proposer before acceptance (terminal) */
+    CONTRACT_STATE_CANCELLED = "CONTRACT_STATE_CANCELLED",
+    UNRECOGNIZED = "UNRECOGNIZED"
+}
+export declare function contractStateFromJSON(object: any): ContractState;
+export declare function contractStateToJSON(object: ContractState): string;
+export declare function contractStateToNumber(object: ContractState): number;
+/** Contract between two agents */
+export interface Contract {
+    id: string;
+    /** Human-readable ID */
+    contractId: string;
+    proposer: string;
+    counterparty: string;
+    state: ContractState;
+    /** Flexible terms structure */
+    terms?: {
+        [key: string]: any;
+    } | undefined;
+    proposedAt?: Date | undefined;
+    acceptedAt?: Date | undefined;
+    completedAt?: Date | undefined;
+    /** Evidence of completion */
+    completionProof: string;
+}
+/** Propose a new contract */
+export interface ProposeContractRequest {
+    proposer: string;
+    counterparty: string;
+    terms?: {
+        [key: string]: any;
+    } | undefined;
+    description: string;
+}
+/** Accept a proposed contract */
+export interface AcceptContractRequest {
+    contractId: string;
+    acceptor: string;
+}
+/** Complete a contract with proof */
+export interface CompleteContractRequest {
+    contractId: string;
+    completer: string;
+    proof: string;
+}
+/** Reject a proposed contract */
+export interface RejectContractRequest {
+    contractId: string;
+    rejector: string;
+    reason: string;
+}
+/** Dispute a contract */
+export interface DisputeContractRequest {
+    contractId: string;
+    disputant: string;
+    evidence: string;
+    reason: string;
+}
+/** Contract state machine definition */
+export interface ContractDefinition {
+    /** Both parties must sign completion */
+    requireBothSignatures: boolean;
+    /** How long after completion disputes allowed */
+    disputeWindowEpochs: number;
+}
+export declare const Contract: MessageFns<Contract>;
+export declare const ProposeContractRequest: MessageFns<ProposeContractRequest>;
+export declare const AcceptContractRequest: MessageFns<AcceptContractRequest>;
+export declare const CompleteContractRequest: MessageFns<CompleteContractRequest>;
+export declare const RejectContractRequest: MessageFns<RejectContractRequest>;
+export declare const DisputeContractRequest: MessageFns<DisputeContractRequest>;
+export declare const ContractDefinition: MessageFns<ContractDefinition>;
+type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;
+export type DeepPartial<T> = T extends Builtin ? T : T extends globalThis.Array<infer U> ? globalThis.Array<DeepPartial<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>> : T extends {
+    $case: string;
+} ? {
+    [K in keyof Omit<T, "$case">]?: DeepPartial<T[K]>;
+} & {
+    $case: T["$case"];
+} : T extends {} ? {
+    [K in keyof T]?: DeepPartial<T[K]>;
+} : Partial<T>;
+type KeysOfUnion<T> = T extends T ? keyof T : never;
+export type Exact<P, I extends P> = P extends Builtin ? P : P & {
+    [K in keyof P]: Exact<P[K], I[K]>;
+} & {
+    [K in Exclude<keyof I, KeysOfUnion<P>>]: never;
+};
+export interface MessageFns<T> {
+    encode(message: T, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): T;
+    fromJSON(object: any): T;
+    toJSON(message: T): unknown;
+    create<I extends Exact<DeepPartial<T>, I>>(base?: I): T;
+    fromPartial<I extends Exact<DeepPartial<T>, I>>(object: I): T;
+}
+export {};

package/dist/types/generated/ottochain/apps/contracts/v1/contract_pb.d.ts

@@ -0,0 +1,274 @@
+import type { GenEnum, GenFile, GenMessage } from "@bufbuild/protobuf/codegenv1";
+import type { Address } from "../../../v1/common_pb.js";
+import type { Timestamp } from "@bufbuild/protobuf/wkt";
+import type { JsonObject, Message } from "@bufbuild/protobuf";
+/**
+ * Describes the file ottochain/apps/contracts/v1/contract.proto.
+ */
+export declare const file_ottochain_apps_contracts_v1_contract: GenFile;
+/**
+ * Contract between two agents
+ *
+ * @generated from message ottochain.apps.contracts.v1.Contract
+ */
+export type Contract = Message<"ottochain.apps.contracts.v1.Contract"> & {
+    /**
+     * @generated from field: string id = 1;
+     */
+    id: string;
+    /**
+     * Human-readable ID
+     *
+     * @generated from field: string contract_id = 2;
+     */
+    contractId: string;
+    /**
+     * @generated from field: ottochain.v1.Address proposer = 3;
+     */
+    proposer?: Address;
+    /**
+     * @generated from field: ottochain.v1.Address counterparty = 4;
+     */
+    counterparty?: Address;
+    /**
+     * @generated from field: ottochain.apps.contracts.v1.ContractState state = 5;
+     */
+    state: ContractState;
+    /**
+     * Flexible terms structure
+     *
+     * @generated from field: google.protobuf.Struct terms = 6;
+     */
+    terms?: JsonObject;
+    /**
+     * @generated from field: google.protobuf.Timestamp proposed_at = 7;
+     */
+    proposedAt?: Timestamp;
+    /**
+     * @generated from field: google.protobuf.Timestamp accepted_at = 8;
+     */
+    acceptedAt?: Timestamp;
+    /**
+     * @generated from field: google.protobuf.Timestamp completed_at = 9;
+     */
+    completedAt?: Timestamp;
+    /**
+     * Evidence of completion
+     *
+     * @generated from field: string completion_proof = 10;
+     */
+    completionProof: string;
+};
+/**
+ * Describes the message ottochain.apps.contracts.v1.Contract.
+ * Use `create(ContractSchema)` to create a new message.
+ */
+export declare const ContractSchema: GenMessage<Contract>;
+/**
+ * Propose a new contract
+ *
+ * @generated from message ottochain.apps.contracts.v1.ProposeContractRequest
+ */
+export type ProposeContractRequest = Message<"ottochain.apps.contracts.v1.ProposeContractRequest"> & {
+    /**
+     * @generated from field: ottochain.v1.Address proposer = 1;
+     */
+    proposer?: Address;
+    /**
+     * @generated from field: ottochain.v1.Address counterparty = 2;
+     */
+    counterparty?: Address;
+    /**
+     * @generated from field: google.protobuf.Struct terms = 3;
+     */
+    terms?: JsonObject;
+    /**
+     * @generated from field: string description = 4;
+     */
+    description: string;
+};
+/**
+ * Describes the message ottochain.apps.contracts.v1.ProposeContractRequest.
+ * Use `create(ProposeContractRequestSchema)` to create a new message.
+ */
+export declare const ProposeContractRequestSchema: GenMessage<ProposeContractRequest>;
+/**
+ * Accept a proposed contract
+ *
+ * @generated from message ottochain.apps.contracts.v1.AcceptContractRequest
+ */
+export type AcceptContractRequest = Message<"ottochain.apps.contracts.v1.AcceptContractRequest"> & {
+    /**
+     * @generated from field: string contract_id = 1;
+     */
+    contractId: string;
+    /**
+     * @generated from field: ottochain.v1.Address acceptor = 2;
+     */
+    acceptor?: Address;
+};
+/**
+ * Describes the message ottochain.apps.contracts.v1.AcceptContractRequest.
+ * Use `create(AcceptContractRequestSchema)` to create a new message.
+ */
+export declare const AcceptContractRequestSchema: GenMessage<AcceptContractRequest>;
+/**
+ * Complete a contract with proof
+ *
+ * @generated from message ottochain.apps.contracts.v1.CompleteContractRequest
+ */
+export type CompleteContractRequest = Message<"ottochain.apps.contracts.v1.CompleteContractRequest"> & {
+    /**
+     * @generated from field: string contract_id = 1;
+     */
+    contractId: string;
+    /**
+     * @generated from field: ottochain.v1.Address completer = 2;
+     */
+    completer?: Address;
+    /**
+     * @generated from field: string proof = 3;
+     */
+    proof: string;
+};
+/**
+ * Describes the message ottochain.apps.contracts.v1.CompleteContractRequest.
+ * Use `create(CompleteContractRequestSchema)` to create a new message.
+ */
+export declare const CompleteContractRequestSchema: GenMessage<CompleteContractRequest>;
+/**
+ * Reject a proposed contract
+ *
+ * @generated from message ottochain.apps.contracts.v1.RejectContractRequest
+ */
+export type RejectContractRequest = Message<"ottochain.apps.contracts.v1.RejectContractRequest"> & {
+    /**
+     * @generated from field: string contract_id = 1;
+     */
+    contractId: string;
+    /**
+     * @generated from field: ottochain.v1.Address rejector = 2;
+     */
+    rejector?: Address;
+    /**
+     * @generated from field: string reason = 3;
+     */
+    reason: string;
+};
+/**
+ * Describes the message ottochain.apps.contracts.v1.RejectContractRequest.
+ * Use `create(RejectContractRequestSchema)` to create a new message.
+ */
+export declare const RejectContractRequestSchema: GenMessage<RejectContractRequest>;
+/**
+ * Dispute a contract
+ *
+ * @generated from message ottochain.apps.contracts.v1.DisputeContractRequest
+ */
+export type DisputeContractRequest = Message<"ottochain.apps.contracts.v1.DisputeContractRequest"> & {
+    /**
+     * @generated from field: string contract_id = 1;
+     */
+    contractId: string;
+    /**
+     * @generated from field: ottochain.v1.Address disputant = 2;
+     */
+    disputant?: Address;
+    /**
+     * @generated from field: string evidence = 3;
+     */
+    evidence: string;
+    /**
+     * @generated from field: string reason = 4;
+     */
+    reason: string;
+};
+/**
+ * Describes the message ottochain.apps.contracts.v1.DisputeContractRequest.
+ * Use `create(DisputeContractRequestSchema)` to create a new message.
+ */
+export declare const DisputeContractRequestSchema: GenMessage<DisputeContractRequest>;
+/**
+ * Contract state machine definition
+ *
+ * Valid transitions:
+ *   PROPOSED -> ACTIVE (accept)
+ *   PROPOSED -> REJECTED (reject)
+ *   PROPOSED -> CANCELLED (cancel)
+ *   ACTIVE -> COMPLETED (complete)
+ *   ACTIVE -> DISPUTED (dispute)
+ *   DISPUTED -> COMPLETED (resolve_for_completer)
+ *   DISPUTED -> REJECTED (resolve_for_disputant)
+ *
+ * @generated from message ottochain.apps.contracts.v1.ContractDefinition
+ */
+export type ContractDefinition = Message<"ottochain.apps.contracts.v1.ContractDefinition"> & {
+    /**
+     * Both parties must sign completion
+     *
+     * @generated from field: bool require_both_signatures = 1;
+     */
+    requireBothSignatures: boolean;
+    /**
+     * How long after completion disputes allowed
+     *
+     * @generated from field: int32 dispute_window_epochs = 2;
+     */
+    disputeWindowEpochs: number;
+};
+/**
+ * Describes the message ottochain.apps.contracts.v1.ContractDefinition.
+ * Use `create(ContractDefinitionSchema)` to create a new message.
+ */
+export declare const ContractDefinitionSchema: GenMessage<ContractDefinition>;
+/**
+ * Contract lifecycle states
+ *
+ * @generated from enum ottochain.apps.contracts.v1.ContractState
+ */
+export declare enum ContractState {
+    /**
+     * @generated from enum value: CONTRACT_STATE_UNSPECIFIED = 0;
+     */
+    UNSPECIFIED = 0,
+    /**
+     * Awaiting counterparty acceptance
+     *
+     * @generated from enum value: CONTRACT_STATE_PROPOSED = 1;
+     */
+    PROPOSED = 1,
+    /**
+     * Both parties agreed, in progress
+     *
+     * @generated from enum value: CONTRACT_STATE_ACTIVE = 2;
+     */
+    ACTIVE = 2,
+    /**
+     * Successfully fulfilled (terminal)
+     *
+     * @generated from enum value: CONTRACT_STATE_COMPLETED = 3;
+     */
+    COMPLETED = 3,
+    /**
+     * Counterparty declined (terminal)
+     *
+     * @generated from enum value: CONTRACT_STATE_REJECTED = 4;
+     */
+    REJECTED = 4,
+    /**
+     * Under dispute resolution
+     *
+     * @generated from enum value: CONTRACT_STATE_DISPUTED = 5;
+     */
+    DISPUTED = 5,
+    /**
+     * Cancelled by proposer before acceptance (terminal)
+     *
+     * @generated from enum value: CONTRACT_STATE_CANCELLED = 6;
+     */
+    CANCELLED = 6
+}
+/**
+ * Describes the enum ottochain.apps.contracts.v1.ContractState.
+ */
+export declare const ContractStateSchema: GenEnum<ContractState>;