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

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

import * as jspb from "google-protobuf";
import * as provenance_metadata_v0_types_pb from "../../../provenance/metadata/v0/types_pb";

export class DefinitionSpec extends jspb.Message { 
    getName(): string;
    setName(value: string): DefinitionSpec;

    hasResourceLocation(): boolean;
    clearResourceLocation(): void;
    getResourceLocation(): provenance_metadata_v0_types_pb.Location | undefined;
    setResourceLocation(value?: provenance_metadata_v0_types_pb.Location): DefinitionSpec;

    hasSignature(): boolean;
    clearSignature(): void;
    getSignature(): provenance_metadata_v0_types_pb.Signature | undefined;
    setSignature(value?: provenance_metadata_v0_types_pb.Signature): DefinitionSpec;
    getType(): DefinitionSpecType;
    setType(value: DefinitionSpecType): DefinitionSpec;

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

export namespace DefinitionSpec {
    export type AsObject = {
        name: string,
        resourceLocation?: provenance_metadata_v0_types_pb.Location.AsObject,
        signature?: provenance_metadata_v0_types_pb.Signature.AsObject,
        type: DefinitionSpecType,
    }
}

export class ContractSpec extends jspb.Message { 

    hasDefinition(): boolean;
    clearDefinition(): void;
    getDefinition(): DefinitionSpec | undefined;
    setDefinition(value?: DefinitionSpec): ContractSpec;
    clearInputSpecsList(): void;
    getInputSpecsList(): Array<DefinitionSpec>;
    setInputSpecsList(value: Array<DefinitionSpec>): ContractSpec;
    addInputSpecs(value?: DefinitionSpec, index?: number): DefinitionSpec;
    clearPartiesInvolvedList(): void;
    getPartiesInvolvedList(): Array<provenance_metadata_v0_types_pb.PartyType>;
    setPartiesInvolvedList(value: Array<provenance_metadata_v0_types_pb.PartyType>): ContractSpec;
    addPartiesInvolved(value: provenance_metadata_v0_types_pb.PartyType, index?: number): provenance_metadata_v0_types_pb.PartyType;
    clearConditionSpecsList(): void;
    getConditionSpecsList(): Array<ConditionSpec>;
    setConditionSpecsList(value: Array<ConditionSpec>): ContractSpec;
    addConditionSpecs(value?: ConditionSpec, index?: number): ConditionSpec;
    clearConsiderationSpecsList(): void;
    getConsiderationSpecsList(): Array<ConsiderationSpec>;
    setConsiderationSpecsList(value: Array<ConsiderationSpec>): ContractSpec;
    addConsiderationSpecs(value?: ConsiderationSpec, index?: number): ConsiderationSpec;

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

export namespace ContractSpec {
    export type AsObject = {
        definition?: DefinitionSpec.AsObject,
        inputSpecsList: Array<DefinitionSpec.AsObject>,
        partiesInvolvedList: Array<provenance_metadata_v0_types_pb.PartyType>,
        conditionSpecsList: Array<ConditionSpec.AsObject>,
        considerationSpecsList: Array<ConsiderationSpec.AsObject>,
    }
}

export class ConditionSpec extends jspb.Message { 
    getFuncName(): string;
    setFuncName(value: string): ConditionSpec;
    clearInputSpecsList(): void;
    getInputSpecsList(): Array<DefinitionSpec>;
    setInputSpecsList(value: Array<DefinitionSpec>): ConditionSpec;
    addInputSpecs(value?: DefinitionSpec, index?: number): DefinitionSpec;

    hasOutputSpec(): boolean;
    clearOutputSpec(): void;
    getOutputSpec(): OutputSpec | undefined;
    setOutputSpec(value?: OutputSpec): ConditionSpec;

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

export namespace ConditionSpec {
    export type AsObject = {
        funcName: string,
        inputSpecsList: Array<DefinitionSpec.AsObject>,
        outputSpec?: OutputSpec.AsObject,
    }
}

export class ConsiderationSpec extends jspb.Message { 
    getFuncName(): string;
    setFuncName(value: string): ConsiderationSpec;
    getResponsibleParty(): provenance_metadata_v0_types_pb.PartyType;
    setResponsibleParty(value: provenance_metadata_v0_types_pb.PartyType): ConsiderationSpec;
    clearInputSpecsList(): void;
    getInputSpecsList(): Array<DefinitionSpec>;
    setInputSpecsList(value: Array<DefinitionSpec>): ConsiderationSpec;
    addInputSpecs(value?: DefinitionSpec, index?: number): DefinitionSpec;

    hasOutputSpec(): boolean;
    clearOutputSpec(): void;
    getOutputSpec(): OutputSpec | undefined;
    setOutputSpec(value?: OutputSpec): ConsiderationSpec;

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

export namespace ConsiderationSpec {
    export type AsObject = {
        funcName: string,
        responsibleParty: provenance_metadata_v0_types_pb.PartyType,
        inputSpecsList: Array<DefinitionSpec.AsObject>,
        outputSpec?: OutputSpec.AsObject,
    }
}

export class OutputSpec extends jspb.Message { 

    hasSpec(): boolean;
    clearSpec(): void;
    getSpec(): DefinitionSpec | undefined;
    setSpec(value?: DefinitionSpec): OutputSpec;

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

export namespace OutputSpec {
    export type AsObject = {
        spec?: DefinitionSpec.AsObject,
    }
}

export enum DefinitionSpecType {
    DEFINITION_SPEC_TYPE_UNKNOWN = 0,
    DEFINITION_SPEC_TYPE_PROPOSED = 1,
    DEFINITION_SPEC_TYPE_FACT = 2,
    DEFINITION_SPEC_TYPE_FACT_LIST = 3,
}