// package: contract
// file: provenance/metadata/v0/contract.proto

/* tslint:disable */
/* eslint-disable */

import * as jspb from "google-protobuf";
import * as gogoproto_gogo_pb from "../../../gogoproto/gogo_pb";
import * as provenance_metadata_v0_spec_pb from "../../../provenance/metadata/v0/spec_pb";
import * as provenance_metadata_v0_types_pb from "../../../provenance/metadata/v0/types_pb";
import * as google_protobuf_timestamp_pb from "google-protobuf/google/protobuf/timestamp_pb";

export class Recital extends jspb.Message { 
    getSignerRole(): provenance_metadata_v0_types_pb.PartyType;
    setSignerRole(value: provenance_metadata_v0_types_pb.PartyType): Recital;

    hasSigner(): boolean;
    clearSigner(): void;
    getSigner(): provenance_metadata_v0_types_pb.SigningAndEncryptionPublicKeys | undefined;
    setSigner(value?: provenance_metadata_v0_types_pb.SigningAndEncryptionPublicKeys): Recital;
    getAddress(): Uint8Array | string;
    getAddress_asU8(): Uint8Array;
    getAddress_asB64(): string;
    setAddress(value: Uint8Array | string): Recital;

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): Recital.AsObject;
    static toObject(includeInstance: boolean, msg: Recital): Recital.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: Recital, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): Recital;
    static deserializeBinaryFromReader(message: Recital, reader: jspb.BinaryReader): Recital;
}

export namespace Recital {
    export type AsObject = {
        signerRole: provenance_metadata_v0_types_pb.PartyType,
        signer?: provenance_metadata_v0_types_pb.SigningAndEncryptionPublicKeys.AsObject,
        address: Uint8Array | string,
    }
}

export class Recitals extends jspb.Message { 
    clearPartiesList(): void;
    getPartiesList(): Array<Recital>;
    setPartiesList(value: Array<Recital>): Recitals;
    addParties(value?: Recital, index?: number): Recital;

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): Recitals.AsObject;
    static toObject(includeInstance: boolean, msg: Recitals): Recitals.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: Recitals, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): Recitals;
    static deserializeBinaryFromReader(message: Recitals, reader: jspb.BinaryReader): Recitals;
}

export namespace Recitals {
    export type AsObject = {
        partiesList: Array<Recital.AsObject>,
    }
}

export class Contract extends jspb.Message { 

    hasDefinition(): boolean;
    clearDefinition(): void;
    getDefinition(): provenance_metadata_v0_spec_pb.DefinitionSpec | undefined;
    setDefinition(value?: provenance_metadata_v0_spec_pb.DefinitionSpec): Contract;

    hasSpec(): boolean;
    clearSpec(): void;
    getSpec(): provenance_metadata_v0_types_pb.Fact | undefined;
    setSpec(value?: provenance_metadata_v0_types_pb.Fact): Contract;

    hasInvoker(): boolean;
    clearInvoker(): void;
    getInvoker(): provenance_metadata_v0_types_pb.SigningAndEncryptionPublicKeys | undefined;
    setInvoker(value?: provenance_metadata_v0_types_pb.SigningAndEncryptionPublicKeys): Contract;
    clearInputsList(): void;
    getInputsList(): Array<provenance_metadata_v0_types_pb.Fact>;
    setInputsList(value: Array<provenance_metadata_v0_types_pb.Fact>): Contract;
    addInputs(value?: provenance_metadata_v0_types_pb.Fact, index?: number): provenance_metadata_v0_types_pb.Fact;
    clearConditionsList(): void;
    getConditionsList(): Array<Condition>;
    setConditionsList(value: Array<Condition>): Contract;
    addConditions(value?: Condition, index?: number): Condition;
    clearConsiderationsList(): void;
    getConsiderationsList(): Array<Consideration>;
    setConsiderationsList(value: Array<Consideration>): Contract;
    addConsiderations(value?: Consideration, index?: number): Consideration;
    clearRecitalsList(): void;
    getRecitalsList(): Array<Recital>;
    setRecitalsList(value: Array<Recital>): Contract;
    addRecitals(value?: Recital, index?: number): Recital;
    getTimesExecuted(): number;
    setTimesExecuted(value: number): Contract;

    hasStartTime(): boolean;
    clearStartTime(): void;
    getStartTime(): google_protobuf_timestamp_pb.Timestamp | undefined;
    setStartTime(value?: google_protobuf_timestamp_pb.Timestamp): Contract;

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): Contract.AsObject;
    static toObject(includeInstance: boolean, msg: Contract): Contract.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: Contract, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): Contract;
    static deserializeBinaryFromReader(message: Contract, reader: jspb.BinaryReader): Contract;
}

export namespace Contract {
    export type AsObject = {
        definition?: provenance_metadata_v0_spec_pb.DefinitionSpec.AsObject,
        spec?: provenance_metadata_v0_types_pb.Fact.AsObject,
        invoker?: provenance_metadata_v0_types_pb.SigningAndEncryptionPublicKeys.AsObject,
        inputsList: Array<provenance_metadata_v0_types_pb.Fact.AsObject>,
        conditionsList: Array<Condition.AsObject>,
        considerationsList: Array<Consideration.AsObject>,
        recitalsList: Array<Recital.AsObject>,
        timesExecuted: number,
        startTime?: google_protobuf_timestamp_pb.Timestamp.AsObject,
    }
}

export class Condition extends jspb.Message { 
    getConditionName(): string;
    setConditionName(value: string): Condition;

    hasResult(): boolean;
    clearResult(): void;
    getResult(): ExecutionResult | undefined;
    setResult(value?: ExecutionResult): Condition;

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): Condition.AsObject;
    static toObject(includeInstance: boolean, msg: Condition): Condition.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: Condition, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): Condition;
    static deserializeBinaryFromReader(message: Condition, reader: jspb.BinaryReader): Condition;
}

export namespace Condition {
    export type AsObject = {
        conditionName: string,
        result?: ExecutionResult.AsObject,
    }
}

export class Consideration extends jspb.Message { 
    getConsiderationName(): string;
    setConsiderationName(value: string): Consideration;
    clearInputsList(): void;
    getInputsList(): Array<ProposedFact>;
    setInputsList(value: Array<ProposedFact>): Consideration;
    addInputs(value?: ProposedFact, index?: number): ProposedFact;

    hasResult(): boolean;
    clearResult(): void;
    getResult(): ExecutionResult | undefined;
    setResult(value?: ExecutionResult): Consideration;

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): Consideration.AsObject;
    static toObject(includeInstance: boolean, msg: Consideration): Consideration.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: Consideration, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): Consideration;
    static deserializeBinaryFromReader(message: Consideration, reader: jspb.BinaryReader): Consideration;
}

export namespace Consideration {
    export type AsObject = {
        considerationName: string,
        inputsList: Array<ProposedFact.AsObject>,
        result?: ExecutionResult.AsObject,
    }
}

export class ProposedFact extends jspb.Message { 
    getName(): string;
    setName(value: string): ProposedFact;
    getHash(): string;
    setHash(value: string): ProposedFact;
    getClassname(): string;
    setClassname(value: string): ProposedFact;

    hasAncestor(): boolean;
    clearAncestor(): void;
    getAncestor(): provenance_metadata_v0_types_pb.ProvenanceReference | undefined;
    setAncestor(value?: provenance_metadata_v0_types_pb.ProvenanceReference): ProposedFact;

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): ProposedFact.AsObject;
    static toObject(includeInstance: boolean, msg: ProposedFact): ProposedFact.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: ProposedFact, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): ProposedFact;
    static deserializeBinaryFromReader(message: ProposedFact, reader: jspb.BinaryReader): ProposedFact;
}

export namespace ProposedFact {
    export type AsObject = {
        name: string,
        hash: string,
        classname: string,
        ancestor?: provenance_metadata_v0_types_pb.ProvenanceReference.AsObject,
    }
}

export class ExecutionResult extends jspb.Message { 

    hasOutput(): boolean;
    clearOutput(): void;
    getOutput(): ProposedFact | undefined;
    setOutput(value?: ProposedFact): ExecutionResult;
    getResult(): ExecutionResultType;
    setResult(value: ExecutionResultType): ExecutionResult;

    hasRecordedAt(): boolean;
    clearRecordedAt(): void;
    getRecordedAt(): google_protobuf_timestamp_pb.Timestamp | undefined;
    setRecordedAt(value?: google_protobuf_timestamp_pb.Timestamp): ExecutionResult;
    getErrorMessage(): string;
    setErrorMessage(value: string): ExecutionResult;

    serializeBinary(): Uint8Array;
    toObject(includeInstance?: boolean): ExecutionResult.AsObject;
    static toObject(includeInstance: boolean, msg: ExecutionResult): ExecutionResult.AsObject;
    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    static serializeBinaryToWriter(message: ExecutionResult, writer: jspb.BinaryWriter): void;
    static deserializeBinary(bytes: Uint8Array): ExecutionResult;
    static deserializeBinaryFromReader(message: ExecutionResult, reader: jspb.BinaryReader): ExecutionResult;
}

export namespace ExecutionResult {
    export type AsObject = {
        output?: ProposedFact.AsObject,
        result: ExecutionResultType,
        recordedAt?: google_protobuf_timestamp_pb.Timestamp.AsObject,
        errorMessage: string,
    }
}

export enum ExecutionResultType {
    RESULT_TYPE_UNKNOWN = 0,
    RESULT_TYPE_PASS = 1,
    RESULT_TYPE_SKIP = 2,
    RESULT_TYPE_FAIL = 3,
}