/* eslint-disable */
import Long from 'long';
import _m0 from 'protobufjs/minimal';
import { Header, Data, Commit } from '../../tendermint/types/types';
import { EvidenceList } from '../../tendermint/types/evidence';

export const protobufPackage = 'tendermint.types';

export interface Block {
    header?: Header;
    data?: Data;
    evidence?: EvidenceList;
    lastCommit?: Commit;
}

const baseBlock: object = {};

export const Block = {
    encode(message: Block, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
        if (message.header !== undefined) {
            Header.encode(message.header, writer.uint32(10).fork()).ldelim();
        }
        if (message.data !== undefined) {
            Data.encode(message.data, writer.uint32(18).fork()).ldelim();
        }
        if (message.evidence !== undefined) {
            EvidenceList.encode(message.evidence, writer.uint32(26).fork()).ldelim();
        }
        if (message.lastCommit !== undefined) {
            Commit.encode(message.lastCommit, writer.uint32(34).fork()).ldelim();
        }
        return writer;
    },

    decode(input: _m0.Reader | Uint8Array, length?: number): Block {
        const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = { ...baseBlock } as Block;
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.header = Header.decode(reader, reader.uint32());
                    break;
                case 2:
                    message.data = Data.decode(reader, reader.uint32());
                    break;
                case 3:
                    message.evidence = EvidenceList.decode(reader, reader.uint32());
                    break;
                case 4:
                    message.lastCommit = Commit.decode(reader, reader.uint32());
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },

    fromJSON(object: any): Block {
        const message = { ...baseBlock } as Block;
        if (object.header !== undefined && object.header !== null) {
            message.header = Header.fromJSON(object.header);
        } else {
            message.header = undefined;
        }
        if (object.data !== undefined && object.data !== null) {
            message.data = Data.fromJSON(object.data);
        } else {
            message.data = undefined;
        }
        if (object.evidence !== undefined && object.evidence !== null) {
            message.evidence = EvidenceList.fromJSON(object.evidence);
        } else {
            message.evidence = undefined;
        }
        if (object.lastCommit !== undefined && object.lastCommit !== null) {
            message.lastCommit = Commit.fromJSON(object.lastCommit);
        } else {
            message.lastCommit = undefined;
        }
        return message;
    },

    toJSON(message: Block): unknown {
        const obj: any = {};
        message.header !== undefined && (obj.header = message.header ? Header.toJSON(message.header) : undefined);
        message.data !== undefined && (obj.data = message.data ? Data.toJSON(message.data) : undefined);
        message.evidence !== undefined &&
            (obj.evidence = message.evidence ? EvidenceList.toJSON(message.evidence) : undefined);
        message.lastCommit !== undefined &&
            (obj.lastCommit = message.lastCommit ? Commit.toJSON(message.lastCommit) : undefined);
        return obj;
    },

    fromPartial(object: DeepPartial<Block>): Block {
        const message = { ...baseBlock } as Block;
        if (object.header !== undefined && object.header !== null) {
            message.header = Header.fromPartial(object.header);
        } else {
            message.header = undefined;
        }
        if (object.data !== undefined && object.data !== null) {
            message.data = Data.fromPartial(object.data);
        } else {
            message.data = undefined;
        }
        if (object.evidence !== undefined && object.evidence !== null) {
            message.evidence = EvidenceList.fromPartial(object.evidence);
        } else {
            message.evidence = undefined;
        }
        if (object.lastCommit !== undefined && object.lastCommit !== null) {
            message.lastCommit = Commit.fromPartial(object.lastCommit);
        } else {
            message.lastCommit = undefined;
        }
        return message;
    },
};

type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined | Long;
export type DeepPartial<T> = T extends Builtin
    ? T
    : T extends Array<infer U>
    ? Array<DeepPartial<U>>
    : T extends ReadonlyArray<infer U>
    ? ReadonlyArray<DeepPartial<U>>
    : T extends {}
    ? { [K in keyof T]?: DeepPartial<T[K]> }
    : Partial<T>;

if (_m0.util.Long !== Long) {
    _m0.util.Long = Long as any;
    _m0.configure();
}