@gitopia/gitopiajs 0.0.4 → 0.0.6

package/dist/gitopia/gitopia/gitopia/genesis.d.ts

@@ -0,0 +1,143 @@
+import { ExercisedAmount, ExercisedAmountAmino, ExercisedAmountSDKType } from "./exercised_amount";
+import { Params, ParamsAmino, ParamsSDKType } from "./params";
+import { Bounty, BountyAmino, BountySDKType } from "./bounty";
+import { UserDao, UserDaoAmino, UserDaoSDKType, User, UserAmino, UserSDKType } from "./user";
+import { BaseRepositoryKey, BaseRepositoryKeyAmino, BaseRepositoryKeySDKType, Repository, RepositoryAmino, RepositorySDKType } from "./repository";
+import { Tag, TagAmino, TagSDKType } from "./tag";
+import { Branch, BranchAmino, BranchSDKType } from "./branch";
+import { Task, TaskAmino, TaskSDKType } from "./task";
+import { Release, ReleaseAmino, ReleaseSDKType } from "./release";
+import { PullRequest, PullRequestAmino, PullRequestSDKType } from "./pullRequest";
+import { Dao, DaoAmino, DaoSDKType } from "./dao";
+import { Comment, CommentAmino, CommentSDKType } from "./comment";
+import { Issue, IssueAmino, IssueSDKType } from "./issue";
+import { Whois, WhoisAmino, WhoisSDKType } from "./whois";
+import { BinaryReader, BinaryWriter } from "../../../binary";
+/** GenesisState defines the gitopia module's genesis state. */
+export interface GenesisState {
+    exercisedAmountList: ExercisedAmount[];
+    exercisedAmountCount: bigint;
+    /** params defines all the paramaters of the module. */
+    params: Params;
+    bountyList: Bounty[];
+    bountyCount: bigint;
+    userDaoList: UserDao[];
+    baseRepositoryKeyList: BaseRepositoryKey[];
+    /**
+     * TODO:
+     * repeated Member memberList = 23 [(gogoproto.nullable) = false];
+     * uint64 memberCount = 24;
+     */
+    tagList: Tag[];
+    tagCount: bigint;
+    branchList: Branch[];
+    branchCount: bigint;
+    taskList: Task[];
+    taskCount: bigint;
+    releaseList: Release[];
+    releaseCount: bigint;
+    pullRequestList: PullRequest[];
+    pullRequestCount: bigint;
+    daoList: Dao[];
+    daoCount: bigint;
+    commentList: Comment[];
+    commentCount: bigint;
+    issueList: Issue[];
+    issueCount: bigint;
+    repositoryList: Repository[];
+    repositoryCount: bigint;
+    userList: User[];
+    userCount: bigint;
+    whoisList: Whois[];
+    whoisCount: bigint;
+}
+export interface GenesisStateProtoMsg {
+    typeUrl: "/gitopia.gitopia.gitopia.GenesisState";
+    value: Uint8Array;
+}
+/** GenesisState defines the gitopia module's genesis state. */
+export interface GenesisStateAmino {
+    exercisedAmountList?: ExercisedAmountAmino[];
+    exercisedAmountCount?: string;
+    /** params defines all the paramaters of the module. */
+    params?: ParamsAmino;
+    bountyList?: BountyAmino[];
+    bountyCount?: string;
+    userDaoList?: UserDaoAmino[];
+    baseRepositoryKeyList?: BaseRepositoryKeyAmino[];
+    /**
+     * TODO:
+     * repeated Member memberList = 23 [(gogoproto.nullable) = false];
+     * uint64 memberCount = 24;
+     */
+    tagList?: TagAmino[];
+    tagCount?: string;
+    branchList?: BranchAmino[];
+    branchCount?: string;
+    taskList?: TaskAmino[];
+    taskCount?: string;
+    releaseList?: ReleaseAmino[];
+    releaseCount?: string;
+    pullRequestList?: PullRequestAmino[];
+    pullRequestCount?: string;
+    daoList?: DaoAmino[];
+    daoCount?: string;
+    commentList?: CommentAmino[];
+    commentCount?: string;
+    issueList?: IssueAmino[];
+    issueCount?: string;
+    repositoryList?: RepositoryAmino[];
+    repositoryCount?: string;
+    userList?: UserAmino[];
+    userCount?: string;
+    whoisList?: WhoisAmino[];
+    whoisCount?: string;
+}
+export interface GenesisStateAminoMsg {
+    type: "/gitopia.gitopia.gitopia.GenesisState";
+    value: GenesisStateAmino;
+}
+/** GenesisState defines the gitopia module's genesis state. */
+export interface GenesisStateSDKType {
+    exercisedAmountList: ExercisedAmountSDKType[];
+    exercisedAmountCount: bigint;
+    params: ParamsSDKType;
+    bountyList: BountySDKType[];
+    bountyCount: bigint;
+    userDaoList: UserDaoSDKType[];
+    baseRepositoryKeyList: BaseRepositoryKeySDKType[];
+    tagList: TagSDKType[];
+    tagCount: bigint;
+    branchList: BranchSDKType[];
+    branchCount: bigint;
+    taskList: TaskSDKType[];
+    taskCount: bigint;
+    releaseList: ReleaseSDKType[];
+    releaseCount: bigint;
+    pullRequestList: PullRequestSDKType[];
+    pullRequestCount: bigint;
+    daoList: DaoSDKType[];
+    daoCount: bigint;
+    commentList: CommentSDKType[];
+    commentCount: bigint;
+    issueList: IssueSDKType[];
+    issueCount: bigint;
+    repositoryList: RepositorySDKType[];
+    repositoryCount: bigint;
+    userList: UserSDKType[];
+    userCount: bigint;
+    whoisList: WhoisSDKType[];
+    whoisCount: bigint;
+}
+export declare const GenesisState: {
+    typeUrl: string;
+    encode(message: GenesisState, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): GenesisState;
+    fromPartial(object: Partial<GenesisState>): GenesisState;
+    fromAmino(object: GenesisStateAmino): GenesisState;
+    toAmino(message: GenesisState): GenesisStateAmino;
+    fromAminoMsg(object: GenesisStateAminoMsg): GenesisState;
+    fromProtoMsg(message: GenesisStateProtoMsg): GenesisState;
+    toProto(message: GenesisState): Uint8Array;
+    toProtoMsg(message: GenesisState): GenesisStateProtoMsg;
+};

package/dist/gitopia/gitopia/gitopia/genesis.js

@@ -0,0 +1,463 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GenesisState = void 0;
+//@ts-nocheck
+const exercised_amount_1 = require("./exercised_amount");
+const params_1 = require("./params");
+const bounty_1 = require("./bounty");
+const user_1 = require("./user");
+const repository_1 = require("./repository");
+const tag_1 = require("./tag");
+const branch_1 = require("./branch");
+const task_1 = require("./task");
+const release_1 = require("./release");
+const pullRequest_1 = require("./pullRequest");
+const dao_1 = require("./dao");
+const comment_1 = require("./comment");
+const issue_1 = require("./issue");
+const whois_1 = require("./whois");
+const binary_1 = require("../../../binary");
+function createBaseGenesisState() {
+    return {
+        exercisedAmountList: [],
+        exercisedAmountCount: BigInt(0),
+        params: params_1.Params.fromPartial({}),
+        bountyList: [],
+        bountyCount: BigInt(0),
+        userDaoList: [],
+        baseRepositoryKeyList: [],
+        tagList: [],
+        tagCount: BigInt(0),
+        branchList: [],
+        branchCount: BigInt(0),
+        taskList: [],
+        taskCount: BigInt(0),
+        releaseList: [],
+        releaseCount: BigInt(0),
+        pullRequestList: [],
+        pullRequestCount: BigInt(0),
+        daoList: [],
+        daoCount: BigInt(0),
+        commentList: [],
+        commentCount: BigInt(0),
+        issueList: [],
+        issueCount: BigInt(0),
+        repositoryList: [],
+        repositoryCount: BigInt(0),
+        userList: [],
+        userCount: BigInt(0),
+        whoisList: [],
+        whoisCount: BigInt(0)
+    };
+}
+exports.GenesisState = {
+    typeUrl: "/gitopia.gitopia.gitopia.GenesisState",
+    encode(message, writer = binary_1.BinaryWriter.create()) {
+        for (const v of message.exercisedAmountList) {
+            exercised_amount_1.ExercisedAmount.encode(v, writer.uint32(242).fork()).ldelim();
+        }
+        if (message.exercisedAmountCount !== BigInt(0)) {
+            writer.uint32(248).uint64(message.exercisedAmountCount);
+        }
+        if (message.params !== undefined) {
+            params_1.Params.encode(message.params, writer.uint32(234).fork()).ldelim();
+        }
+        for (const v of message.bountyList) {
+            bounty_1.Bounty.encode(v, writer.uint32(218).fork()).ldelim();
+        }
+        if (message.bountyCount !== BigInt(0)) {
+            writer.uint32(224).uint64(message.bountyCount);
+        }
+        for (const v of message.userDaoList) {
+            user_1.UserDao.encode(v, writer.uint32(202).fork()).ldelim();
+        }
+        for (const v of message.baseRepositoryKeyList) {
+            repository_1.BaseRepositoryKey.encode(v, writer.uint32(210).fork()).ldelim();
+        }
+        for (const v of message.tagList) {
+            tag_1.Tag.encode(v, writer.uint32(170).fork()).ldelim();
+        }
+        if (message.tagCount !== BigInt(0)) {
+            writer.uint32(176).uint64(message.tagCount);
+        }
+        for (const v of message.branchList) {
+            branch_1.Branch.encode(v, writer.uint32(154).fork()).ldelim();
+        }
+        if (message.branchCount !== BigInt(0)) {
+            writer.uint32(160).uint64(message.branchCount);
+        }
+        for (const v of message.taskList) {
+            task_1.Task.encode(v, writer.uint32(138).fork()).ldelim();
+        }
+        if (message.taskCount !== BigInt(0)) {
+            writer.uint32(144).uint64(message.taskCount);
+        }
+        for (const v of message.releaseList) {
+            release_1.Release.encode(v, writer.uint32(122).fork()).ldelim();
+        }
+        if (message.releaseCount !== BigInt(0)) {
+            writer.uint32(128).uint64(message.releaseCount);
+        }
+        for (const v of message.pullRequestList) {
+            pullRequest_1.PullRequest.encode(v, writer.uint32(106).fork()).ldelim();
+        }
+        if (message.pullRequestCount !== BigInt(0)) {
+            writer.uint32(112).uint64(message.pullRequestCount);
+        }
+        for (const v of message.daoList) {
+            dao_1.Dao.encode(v, writer.uint32(90).fork()).ldelim();
+        }
+        if (message.daoCount !== BigInt(0)) {
+            writer.uint32(96).uint64(message.daoCount);
+        }
+        for (const v of message.commentList) {
+            comment_1.Comment.encode(v, writer.uint32(74).fork()).ldelim();
+        }
+        if (message.commentCount !== BigInt(0)) {
+            writer.uint32(80).uint64(message.commentCount);
+        }
+        for (const v of message.issueList) {
+            issue_1.Issue.encode(v, writer.uint32(58).fork()).ldelim();
+        }
+        if (message.issueCount !== BigInt(0)) {
+            writer.uint32(64).uint64(message.issueCount);
+        }
+        for (const v of message.repositoryList) {
+            repository_1.Repository.encode(v, writer.uint32(42).fork()).ldelim();
+        }
+        if (message.repositoryCount !== BigInt(0)) {
+            writer.uint32(48).uint64(message.repositoryCount);
+        }
+        for (const v of message.userList) {
+            user_1.User.encode(v, writer.uint32(26).fork()).ldelim();
+        }
+        if (message.userCount !== BigInt(0)) {
+            writer.uint32(32).uint64(message.userCount);
+        }
+        for (const v of message.whoisList) {
+            whois_1.Whois.encode(v, writer.uint32(10).fork()).ldelim();
+        }
+        if (message.whoisCount !== BigInt(0)) {
+            writer.uint32(16).uint64(message.whoisCount);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof binary_1.BinaryReader ? input : new binary_1.BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseGenesisState();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 30:
+                    message.exercisedAmountList.push(exercised_amount_1.ExercisedAmount.decode(reader, reader.uint32()));
+                    break;
+                case 31:
+                    message.exercisedAmountCount = reader.uint64();
+                    break;
+                case 29:
+                    message.params = params_1.Params.decode(reader, reader.uint32());
+                    break;
+                case 27:
+                    message.bountyList.push(bounty_1.Bounty.decode(reader, reader.uint32()));
+                    break;
+                case 28:
+                    message.bountyCount = reader.uint64();
+                    break;
+                case 25:
+                    message.userDaoList.push(user_1.UserDao.decode(reader, reader.uint32()));
+                    break;
+                case 26:
+                    message.baseRepositoryKeyList.push(repository_1.BaseRepositoryKey.decode(reader, reader.uint32()));
+                    break;
+                case 21:
+                    message.tagList.push(tag_1.Tag.decode(reader, reader.uint32()));
+                    break;
+                case 22:
+                    message.tagCount = reader.uint64();
+                    break;
+                case 19:
+                    message.branchList.push(branch_1.Branch.decode(reader, reader.uint32()));
+                    break;
+                case 20:
+                    message.branchCount = reader.uint64();
+                    break;
+                case 17:
+                    message.taskList.push(task_1.Task.decode(reader, reader.uint32()));
+                    break;
+                case 18:
+                    message.taskCount = reader.uint64();
+                    break;
+                case 15:
+                    message.releaseList.push(release_1.Release.decode(reader, reader.uint32()));
+                    break;
+                case 16:
+                    message.releaseCount = reader.uint64();
+                    break;
+                case 13:
+                    message.pullRequestList.push(pullRequest_1.PullRequest.decode(reader, reader.uint32()));
+                    break;
+                case 14:
+                    message.pullRequestCount = reader.uint64();
+                    break;
+                case 11:
+                    message.daoList.push(dao_1.Dao.decode(reader, reader.uint32()));
+                    break;
+                case 12:
+                    message.daoCount = reader.uint64();
+                    break;
+                case 9:
+                    message.commentList.push(comment_1.Comment.decode(reader, reader.uint32()));
+                    break;
+                case 10:
+                    message.commentCount = reader.uint64();
+                    break;
+                case 7:
+                    message.issueList.push(issue_1.Issue.decode(reader, reader.uint32()));
+                    break;
+                case 8:
+                    message.issueCount = reader.uint64();
+                    break;
+                case 5:
+                    message.repositoryList.push(repository_1.Repository.decode(reader, reader.uint32()));
+                    break;
+                case 6:
+                    message.repositoryCount = reader.uint64();
+                    break;
+                case 3:
+                    message.userList.push(user_1.User.decode(reader, reader.uint32()));
+                    break;
+                case 4:
+                    message.userCount = reader.uint64();
+                    break;
+                case 1:
+                    message.whoisList.push(whois_1.Whois.decode(reader, reader.uint32()));
+                    break;
+                case 2:
+                    message.whoisCount = reader.uint64();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseGenesisState();
+        message.exercisedAmountList = object.exercisedAmountList?.map(e => exercised_amount_1.ExercisedAmount.fromPartial(e)) || [];
+        message.exercisedAmountCount = object.exercisedAmountCount !== undefined && object.exercisedAmountCount !== null ? BigInt(object.exercisedAmountCount.toString()) : BigInt(0);
+        message.params = object.params !== undefined && object.params !== null ? params_1.Params.fromPartial(object.params) : undefined;
+        message.bountyList = object.bountyList?.map(e => bounty_1.Bounty.fromPartial(e)) || [];
+        message.bountyCount = object.bountyCount !== undefined && object.bountyCount !== null ? BigInt(object.bountyCount.toString()) : BigInt(0);
+        message.userDaoList = object.userDaoList?.map(e => user_1.UserDao.fromPartial(e)) || [];
+        message.baseRepositoryKeyList = object.baseRepositoryKeyList?.map(e => repository_1.BaseRepositoryKey.fromPartial(e)) || [];
+        message.tagList = object.tagList?.map(e => tag_1.Tag.fromPartial(e)) || [];
+        message.tagCount = object.tagCount !== undefined && object.tagCount !== null ? BigInt(object.tagCount.toString()) : BigInt(0);
+        message.branchList = object.branchList?.map(e => branch_1.Branch.fromPartial(e)) || [];
+        message.branchCount = object.branchCount !== undefined && object.branchCount !== null ? BigInt(object.branchCount.toString()) : BigInt(0);
+        message.taskList = object.taskList?.map(e => task_1.Task.fromPartial(e)) || [];
+        message.taskCount = object.taskCount !== undefined && object.taskCount !== null ? BigInt(object.taskCount.toString()) : BigInt(0);
+        message.releaseList = object.releaseList?.map(e => release_1.Release.fromPartial(e)) || [];
+        message.releaseCount = object.releaseCount !== undefined && object.releaseCount !== null ? BigInt(object.releaseCount.toString()) : BigInt(0);
+        message.pullRequestList = object.pullRequestList?.map(e => pullRequest_1.PullRequest.fromPartial(e)) || [];
+        message.pullRequestCount = object.pullRequestCount !== undefined && object.pullRequestCount !== null ? BigInt(object.pullRequestCount.toString()) : BigInt(0);
+        message.daoList = object.daoList?.map(e => dao_1.Dao.fromPartial(e)) || [];
+        message.daoCount = object.daoCount !== undefined && object.daoCount !== null ? BigInt(object.daoCount.toString()) : BigInt(0);
+        message.commentList = object.commentList?.map(e => comment_1.Comment.fromPartial(e)) || [];
+        message.commentCount = object.commentCount !== undefined && object.commentCount !== null ? BigInt(object.commentCount.toString()) : BigInt(0);
+        message.issueList = object.issueList?.map(e => issue_1.Issue.fromPartial(e)) || [];
+        message.issueCount = object.issueCount !== undefined && object.issueCount !== null ? BigInt(object.issueCount.toString()) : BigInt(0);
+        message.repositoryList = object.repositoryList?.map(e => repository_1.Repository.fromPartial(e)) || [];
+        message.repositoryCount = object.repositoryCount !== undefined && object.repositoryCount !== null ? BigInt(object.repositoryCount.toString()) : BigInt(0);
+        message.userList = object.userList?.map(e => user_1.User.fromPartial(e)) || [];
+        message.userCount = object.userCount !== undefined && object.userCount !== null ? BigInt(object.userCount.toString()) : BigInt(0);
+        message.whoisList = object.whoisList?.map(e => whois_1.Whois.fromPartial(e)) || [];
+        message.whoisCount = object.whoisCount !== undefined && object.whoisCount !== null ? BigInt(object.whoisCount.toString()) : BigInt(0);
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseGenesisState();
+        message.exercisedAmountList = object.exercisedAmountList?.map(e => exercised_amount_1.ExercisedAmount.fromAmino(e)) || [];
+        if (object.exercisedAmountCount !== undefined && object.exercisedAmountCount !== null) {
+            message.exercisedAmountCount = BigInt(object.exercisedAmountCount);
+        }
+        if (object.params !== undefined && object.params !== null) {
+            message.params = params_1.Params.fromAmino(object.params);
+        }
+        message.bountyList = object.bountyList?.map(e => bounty_1.Bounty.fromAmino(e)) || [];
+        if (object.bountyCount !== undefined && object.bountyCount !== null) {
+            message.bountyCount = BigInt(object.bountyCount);
+        }
+        message.userDaoList = object.userDaoList?.map(e => user_1.UserDao.fromAmino(e)) || [];
+        message.baseRepositoryKeyList = object.baseRepositoryKeyList?.map(e => repository_1.BaseRepositoryKey.fromAmino(e)) || [];
+        message.tagList = object.tagList?.map(e => tag_1.Tag.fromAmino(e)) || [];
+        if (object.tagCount !== undefined && object.tagCount !== null) {
+            message.tagCount = BigInt(object.tagCount);
+        }
+        message.branchList = object.branchList?.map(e => branch_1.Branch.fromAmino(e)) || [];
+        if (object.branchCount !== undefined && object.branchCount !== null) {
+            message.branchCount = BigInt(object.branchCount);
+        }
+        message.taskList = object.taskList?.map(e => task_1.Task.fromAmino(e)) || [];
+        if (object.taskCount !== undefined && object.taskCount !== null) {
+            message.taskCount = BigInt(object.taskCount);
+        }
+        message.releaseList = object.releaseList?.map(e => release_1.Release.fromAmino(e)) || [];
+        if (object.releaseCount !== undefined && object.releaseCount !== null) {
+            message.releaseCount = BigInt(object.releaseCount);
+        }
+        message.pullRequestList = object.pullRequestList?.map(e => pullRequest_1.PullRequest.fromAmino(e)) || [];
+        if (object.pullRequestCount !== undefined && object.pullRequestCount !== null) {
+            message.pullRequestCount = BigInt(object.pullRequestCount);
+        }
+        message.daoList = object.daoList?.map(e => dao_1.Dao.fromAmino(e)) || [];
+        if (object.daoCount !== undefined && object.daoCount !== null) {
+            message.daoCount = BigInt(object.daoCount);
+        }
+        message.commentList = object.commentList?.map(e => comment_1.Comment.fromAmino(e)) || [];
+        if (object.commentCount !== undefined && object.commentCount !== null) {
+            message.commentCount = BigInt(object.commentCount);
+        }
+        message.issueList = object.issueList?.map(e => issue_1.Issue.fromAmino(e)) || [];
+        if (object.issueCount !== undefined && object.issueCount !== null) {
+            message.issueCount = BigInt(object.issueCount);
+        }
+        message.repositoryList = object.repositoryList?.map(e => repository_1.Repository.fromAmino(e)) || [];
+        if (object.repositoryCount !== undefined && object.repositoryCount !== null) {
+            message.repositoryCount = BigInt(object.repositoryCount);
+        }
+        message.userList = object.userList?.map(e => user_1.User.fromAmino(e)) || [];
+        if (object.userCount !== undefined && object.userCount !== null) {
+            message.userCount = BigInt(object.userCount);
+        }
+        message.whoisList = object.whoisList?.map(e => whois_1.Whois.fromAmino(e)) || [];
+        if (object.whoisCount !== undefined && object.whoisCount !== null) {
+            message.whoisCount = BigInt(object.whoisCount);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        if (message.exercisedAmountList) {
+            obj.exercisedAmountList = message.exercisedAmountList.map(e => e ? exercised_amount_1.ExercisedAmount.toAmino(e) : undefined);
+        }
+        else {
+            obj.exercisedAmountList = message.exercisedAmountList;
+        }
+        obj.exercisedAmountCount = message.exercisedAmountCount !== BigInt(0) ? message.exercisedAmountCount?.toString() : undefined;
+        obj.params = message.params ? params_1.Params.toAmino(message.params) : undefined;
+        if (message.bountyList) {
+            obj.bountyList = message.bountyList.map(e => e ? bounty_1.Bounty.toAmino(e) : undefined);
+        }
+        else {
+            obj.bountyList = message.bountyList;
+        }
+        obj.bountyCount = message.bountyCount !== BigInt(0) ? message.bountyCount?.toString() : undefined;
+        if (message.userDaoList) {
+            obj.userDaoList = message.userDaoList.map(e => e ? user_1.UserDao.toAmino(e) : undefined);
+        }
+        else {
+            obj.userDaoList = message.userDaoList;
+        }
+        if (message.baseRepositoryKeyList) {
+            obj.baseRepositoryKeyList = message.baseRepositoryKeyList.map(e => e ? repository_1.BaseRepositoryKey.toAmino(e) : undefined);
+        }
+        else {
+            obj.baseRepositoryKeyList = message.baseRepositoryKeyList;
+        }
+        if (message.tagList) {
+            obj.tagList = message.tagList.map(e => e ? tag_1.Tag.toAmino(e) : undefined);
+        }
+        else {
+            obj.tagList = message.tagList;
+        }
+        obj.tagCount = message.tagCount !== BigInt(0) ? message.tagCount?.toString() : undefined;
+        if (message.branchList) {
+            obj.branchList = message.branchList.map(e => e ? branch_1.Branch.toAmino(e) : undefined);
+        }
+        else {
+            obj.branchList = message.branchList;
+        }
+        obj.branchCount = message.branchCount !== BigInt(0) ? message.branchCount?.toString() : undefined;
+        if (message.taskList) {
+            obj.taskList = message.taskList.map(e => e ? task_1.Task.toAmino(e) : undefined);
+        }
+        else {
+            obj.taskList = message.taskList;
+        }
+        obj.taskCount = message.taskCount !== BigInt(0) ? message.taskCount?.toString() : undefined;
+        if (message.releaseList) {
+            obj.releaseList = message.releaseList.map(e => e ? release_1.Release.toAmino(e) : undefined);
+        }
+        else {
+            obj.releaseList = message.releaseList;
+        }
+        obj.releaseCount = message.releaseCount !== BigInt(0) ? message.releaseCount?.toString() : undefined;
+        if (message.pullRequestList) {
+            obj.pullRequestList = message.pullRequestList.map(e => e ? pullRequest_1.PullRequest.toAmino(e) : undefined);
+        }
+        else {
+            obj.pullRequestList = message.pullRequestList;
+        }
+        obj.pullRequestCount = message.pullRequestCount !== BigInt(0) ? message.pullRequestCount?.toString() : undefined;
+        if (message.daoList) {
+            obj.daoList = message.daoList.map(e => e ? dao_1.Dao.toAmino(e) : undefined);
+        }
+        else {
+            obj.daoList = message.daoList;
+        }
+        obj.daoCount = message.daoCount !== BigInt(0) ? message.daoCount?.toString() : undefined;
+        if (message.commentList) {
+            obj.commentList = message.commentList.map(e => e ? comment_1.Comment.toAmino(e) : undefined);
+        }
+        else {
+            obj.commentList = message.commentList;
+        }
+        obj.commentCount = message.commentCount !== BigInt(0) ? message.commentCount?.toString() : undefined;
+        if (message.issueList) {
+            obj.issueList = message.issueList.map(e => e ? issue_1.Issue.toAmino(e) : undefined);
+        }
+        else {
+            obj.issueList = message.issueList;
+        }
+        obj.issueCount = message.issueCount !== BigInt(0) ? message.issueCount?.toString() : undefined;
+        if (message.repositoryList) {
+            obj.repositoryList = message.repositoryList.map(e => e ? repository_1.Repository.toAmino(e) : undefined);
+        }
+        else {
+            obj.repositoryList = message.repositoryList;
+        }
+        obj.repositoryCount = message.repositoryCount !== BigInt(0) ? message.repositoryCount?.toString() : undefined;
+        if (message.userList) {
+            obj.userList = message.userList.map(e => e ? user_1.User.toAmino(e) : undefined);
+        }
+        else {
+            obj.userList = message.userList;
+        }
+        obj.userCount = message.userCount !== BigInt(0) ? message.userCount?.toString() : undefined;
+        if (message.whoisList) {
+            obj.whoisList = message.whoisList.map(e => e ? whois_1.Whois.toAmino(e) : undefined);
+        }
+        else {
+            obj.whoisList = message.whoisList;
+        }
+        obj.whoisCount = message.whoisCount !== BigInt(0) ? message.whoisCount?.toString() : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return exports.GenesisState.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return exports.GenesisState.decode(message.value);
+    },
+    toProto(message) {
+        return exports.GenesisState.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/gitopia.gitopia.gitopia.GenesisState",
+            value: exports.GenesisState.encode(message).finish()
+        };
+    }
+};

package/dist/gitopia/gitopia/gitopia/issue.d.ts

@@ -0,0 +1,88 @@
+import { PullRequestIid, PullRequestIidAmino, PullRequestIidSDKType } from "./repository";
+import { BinaryReader, BinaryWriter } from "../../../binary";
+export declare enum Issue_State {
+    OPEN = 0,
+    CLOSED = 1,
+    UNRECOGNIZED = -1
+}
+export declare const Issue_StateSDKType: typeof Issue_State;
+export declare const Issue_StateAmino: typeof Issue_State;
+export declare function issue_StateFromJSON(object: any): Issue_State;
+export declare function issue_StateToJSON(object: Issue_State): string;
+export interface Issue {
+    creator: string;
+    id: bigint;
+    iid: bigint;
+    title: string;
+    state: Issue_State;
+    description: string;
+    commentsCount: bigint;
+    pullRequests: PullRequestIid[];
+    repositoryId: bigint;
+    labels: bigint[];
+    weight: bigint;
+    assignees: string[];
+    bounties: bigint[];
+    createdAt: bigint;
+    updatedAt: bigint;
+    closedAt: bigint;
+    closedBy: string;
+}
+export interface IssueProtoMsg {
+    typeUrl: "/gitopia.gitopia.gitopia.Issue";
+    value: Uint8Array;
+}
+export interface IssueAmino {
+    creator?: string;
+    id?: string;
+    iid?: string;
+    title?: string;
+    state?: Issue_State;
+    description?: string;
+    commentsCount?: string;
+    pullRequests?: PullRequestIidAmino[];
+    repositoryId?: string;
+    labels?: string[];
+    weight?: string;
+    assignees?: string[];
+    bounties?: string[];
+    createdAt?: string;
+    updatedAt?: string;
+    closedAt?: string;
+    closedBy?: string;
+}
+export interface IssueAminoMsg {
+    type: "/gitopia.gitopia.gitopia.Issue";
+    value: IssueAmino;
+}
+export interface IssueSDKType {
+    creator: string;
+    id: bigint;
+    iid: bigint;
+    title: string;
+    state: Issue_State;
+    description: string;
+    commentsCount: bigint;
+    pullRequests: PullRequestIidSDKType[];
+    repositoryId: bigint;
+    labels: bigint[];
+    weight: bigint;
+    assignees: string[];
+    bounties: bigint[];
+    createdAt: bigint;
+    updatedAt: bigint;
+    closedAt: bigint;
+    closedBy: string;
+}
+export declare const Issue: {
+    typeUrl: string;
+    encode(message: Issue, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): Issue;
+    fromPartial(object: Partial<Issue>): Issue;
+    fromAmino(object: IssueAmino): Issue;
+    toAmino(message: Issue): IssueAmino;
+    fromAminoMsg(object: IssueAminoMsg): Issue;
+    fromProtoMsg(message: IssueProtoMsg): Issue;
+    toProto(message: Issue): Uint8Array;
+    toProtoMsg(message: Issue): IssueProtoMsg;
+};