@gitopia/gitopiajs 0.0.4 → 0.0.6

package/dist/gitopia/gitopia/gitopia/comment.js

@@ -0,0 +1,495 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Comment = exports.CommentParentAmino = exports.CommentParentSDKType = exports.CommentParent = exports.CommentTypeAmino = exports.CommentTypeSDKType = exports.CommentType = void 0;
+exports.commentTypeFromJSON = commentTypeFromJSON;
+exports.commentTypeToJSON = commentTypeToJSON;
+exports.commentParentFromJSON = commentParentFromJSON;
+exports.commentParentToJSON = commentParentToJSON;
+//@ts-nocheck
+const attachment_1 = require("./attachment");
+const reaction_1 = require("./reaction");
+const binary_1 = require("../../../binary");
+var CommentType;
+(function (CommentType) {
+    CommentType[CommentType["COMMENT_TYPE_NONE"] = 0] = "COMMENT_TYPE_NONE";
+    CommentType[CommentType["COMMENT_TYPE_REPLY"] = 1] = "COMMENT_TYPE_REPLY";
+    CommentType[CommentType["COMMENT_TYPE_ADD_LABELS"] = 2] = "COMMENT_TYPE_ADD_LABELS";
+    CommentType[CommentType["COMMENT_TYPE_REMOVE_LABELS"] = 3] = "COMMENT_TYPE_REMOVE_LABELS";
+    CommentType[CommentType["COMMENT_TYPE_ADD_ASSIGNEES"] = 4] = "COMMENT_TYPE_ADD_ASSIGNEES";
+    CommentType[CommentType["COMMENT_TYPE_REMOVE_ASSIGNEES"] = 5] = "COMMENT_TYPE_REMOVE_ASSIGNEES";
+    CommentType[CommentType["COMMENT_TYPE_ADD_REVIEWERS"] = 6] = "COMMENT_TYPE_ADD_REVIEWERS";
+    CommentType[CommentType["COMMENT_TYPE_REMOVE_REVIEWERS"] = 7] = "COMMENT_TYPE_REMOVE_REVIEWERS";
+    CommentType[CommentType["COMMENT_TYPE_MODIFIED_TITLE"] = 8] = "COMMENT_TYPE_MODIFIED_TITLE";
+    CommentType[CommentType["COMMENT_TYPE_MODIFIED_DESCRIPTION"] = 9] = "COMMENT_TYPE_MODIFIED_DESCRIPTION";
+    CommentType[CommentType["COMMENT_TYPE_ISSUE_CLOSED"] = 10] = "COMMENT_TYPE_ISSUE_CLOSED";
+    CommentType[CommentType["COMMENT_TYPE_ISSUE_OPENED"] = 11] = "COMMENT_TYPE_ISSUE_OPENED";
+    CommentType[CommentType["COMMENT_TYPE_PULL_REQUEST_CLOSED"] = 12] = "COMMENT_TYPE_PULL_REQUEST_CLOSED";
+    CommentType[CommentType["COMMENT_TYPE_PULL_REQUEST_OPENED"] = 13] = "COMMENT_TYPE_PULL_REQUEST_OPENED";
+    CommentType[CommentType["COMMENT_TYPE_PULL_REQUEST_MERGED"] = 14] = "COMMENT_TYPE_PULL_REQUEST_MERGED";
+    CommentType[CommentType["COMMENT_TYPE_REVIEW"] = 15] = "COMMENT_TYPE_REVIEW";
+    CommentType[CommentType["COMMENT_TYPE_ADD_BOUNTY"] = 16] = "COMMENT_TYPE_ADD_BOUNTY";
+    CommentType[CommentType["COMMENT_TYPE_MODIFIED_BOUNTY"] = 17] = "COMMENT_TYPE_MODIFIED_BOUNTY";
+    CommentType[CommentType["COMMENT_TYPE_CLOSED_BOUNTY"] = 18] = "COMMENT_TYPE_CLOSED_BOUNTY";
+    CommentType[CommentType["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
+})(CommentType || (exports.CommentType = CommentType = {}));
+exports.CommentTypeSDKType = CommentType;
+exports.CommentTypeAmino = CommentType;
+function commentTypeFromJSON(object) {
+    switch (object) {
+        case 0:
+        case "COMMENT_TYPE_NONE":
+            return CommentType.COMMENT_TYPE_NONE;
+        case 1:
+        case "COMMENT_TYPE_REPLY":
+            return CommentType.COMMENT_TYPE_REPLY;
+        case 2:
+        case "COMMENT_TYPE_ADD_LABELS":
+            return CommentType.COMMENT_TYPE_ADD_LABELS;
+        case 3:
+        case "COMMENT_TYPE_REMOVE_LABELS":
+            return CommentType.COMMENT_TYPE_REMOVE_LABELS;
+        case 4:
+        case "COMMENT_TYPE_ADD_ASSIGNEES":
+            return CommentType.COMMENT_TYPE_ADD_ASSIGNEES;
+        case 5:
+        case "COMMENT_TYPE_REMOVE_ASSIGNEES":
+            return CommentType.COMMENT_TYPE_REMOVE_ASSIGNEES;
+        case 6:
+        case "COMMENT_TYPE_ADD_REVIEWERS":
+            return CommentType.COMMENT_TYPE_ADD_REVIEWERS;
+        case 7:
+        case "COMMENT_TYPE_REMOVE_REVIEWERS":
+            return CommentType.COMMENT_TYPE_REMOVE_REVIEWERS;
+        case 8:
+        case "COMMENT_TYPE_MODIFIED_TITLE":
+            return CommentType.COMMENT_TYPE_MODIFIED_TITLE;
+        case 9:
+        case "COMMENT_TYPE_MODIFIED_DESCRIPTION":
+            return CommentType.COMMENT_TYPE_MODIFIED_DESCRIPTION;
+        case 10:
+        case "COMMENT_TYPE_ISSUE_CLOSED":
+            return CommentType.COMMENT_TYPE_ISSUE_CLOSED;
+        case 11:
+        case "COMMENT_TYPE_ISSUE_OPENED":
+            return CommentType.COMMENT_TYPE_ISSUE_OPENED;
+        case 12:
+        case "COMMENT_TYPE_PULL_REQUEST_CLOSED":
+            return CommentType.COMMENT_TYPE_PULL_REQUEST_CLOSED;
+        case 13:
+        case "COMMENT_TYPE_PULL_REQUEST_OPENED":
+            return CommentType.COMMENT_TYPE_PULL_REQUEST_OPENED;
+        case 14:
+        case "COMMENT_TYPE_PULL_REQUEST_MERGED":
+            return CommentType.COMMENT_TYPE_PULL_REQUEST_MERGED;
+        case 15:
+        case "COMMENT_TYPE_REVIEW":
+            return CommentType.COMMENT_TYPE_REVIEW;
+        case 16:
+        case "COMMENT_TYPE_ADD_BOUNTY":
+            return CommentType.COMMENT_TYPE_ADD_BOUNTY;
+        case 17:
+        case "COMMENT_TYPE_MODIFIED_BOUNTY":
+            return CommentType.COMMENT_TYPE_MODIFIED_BOUNTY;
+        case 18:
+        case "COMMENT_TYPE_CLOSED_BOUNTY":
+            return CommentType.COMMENT_TYPE_CLOSED_BOUNTY;
+        case -1:
+        case "UNRECOGNIZED":
+        default:
+            return CommentType.UNRECOGNIZED;
+    }
+}
+function commentTypeToJSON(object) {
+    switch (object) {
+        case CommentType.COMMENT_TYPE_NONE:
+            return "COMMENT_TYPE_NONE";
+        case CommentType.COMMENT_TYPE_REPLY:
+            return "COMMENT_TYPE_REPLY";
+        case CommentType.COMMENT_TYPE_ADD_LABELS:
+            return "COMMENT_TYPE_ADD_LABELS";
+        case CommentType.COMMENT_TYPE_REMOVE_LABELS:
+            return "COMMENT_TYPE_REMOVE_LABELS";
+        case CommentType.COMMENT_TYPE_ADD_ASSIGNEES:
+            return "COMMENT_TYPE_ADD_ASSIGNEES";
+        case CommentType.COMMENT_TYPE_REMOVE_ASSIGNEES:
+            return "COMMENT_TYPE_REMOVE_ASSIGNEES";
+        case CommentType.COMMENT_TYPE_ADD_REVIEWERS:
+            return "COMMENT_TYPE_ADD_REVIEWERS";
+        case CommentType.COMMENT_TYPE_REMOVE_REVIEWERS:
+            return "COMMENT_TYPE_REMOVE_REVIEWERS";
+        case CommentType.COMMENT_TYPE_MODIFIED_TITLE:
+            return "COMMENT_TYPE_MODIFIED_TITLE";
+        case CommentType.COMMENT_TYPE_MODIFIED_DESCRIPTION:
+            return "COMMENT_TYPE_MODIFIED_DESCRIPTION";
+        case CommentType.COMMENT_TYPE_ISSUE_CLOSED:
+            return "COMMENT_TYPE_ISSUE_CLOSED";
+        case CommentType.COMMENT_TYPE_ISSUE_OPENED:
+            return "COMMENT_TYPE_ISSUE_OPENED";
+        case CommentType.COMMENT_TYPE_PULL_REQUEST_CLOSED:
+            return "COMMENT_TYPE_PULL_REQUEST_CLOSED";
+        case CommentType.COMMENT_TYPE_PULL_REQUEST_OPENED:
+            return "COMMENT_TYPE_PULL_REQUEST_OPENED";
+        case CommentType.COMMENT_TYPE_PULL_REQUEST_MERGED:
+            return "COMMENT_TYPE_PULL_REQUEST_MERGED";
+        case CommentType.COMMENT_TYPE_REVIEW:
+            return "COMMENT_TYPE_REVIEW";
+        case CommentType.COMMENT_TYPE_ADD_BOUNTY:
+            return "COMMENT_TYPE_ADD_BOUNTY";
+        case CommentType.COMMENT_TYPE_MODIFIED_BOUNTY:
+            return "COMMENT_TYPE_MODIFIED_BOUNTY";
+        case CommentType.COMMENT_TYPE_CLOSED_BOUNTY:
+            return "COMMENT_TYPE_CLOSED_BOUNTY";
+        case CommentType.UNRECOGNIZED:
+        default:
+            return "UNRECOGNIZED";
+    }
+}
+var CommentParent;
+(function (CommentParent) {
+    CommentParent[CommentParent["COMMENT_PARENT_NONE"] = 0] = "COMMENT_PARENT_NONE";
+    CommentParent[CommentParent["COMMENT_PARENT_ISSUE"] = 1] = "COMMENT_PARENT_ISSUE";
+    CommentParent[CommentParent["COMMENT_PARENT_PULL_REQUEST"] = 2] = "COMMENT_PARENT_PULL_REQUEST";
+    CommentParent[CommentParent["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
+})(CommentParent || (exports.CommentParent = CommentParent = {}));
+exports.CommentParentSDKType = CommentParent;
+exports.CommentParentAmino = CommentParent;
+function commentParentFromJSON(object) {
+    switch (object) {
+        case 0:
+        case "COMMENT_PARENT_NONE":
+            return CommentParent.COMMENT_PARENT_NONE;
+        case 1:
+        case "COMMENT_PARENT_ISSUE":
+            return CommentParent.COMMENT_PARENT_ISSUE;
+        case 2:
+        case "COMMENT_PARENT_PULL_REQUEST":
+            return CommentParent.COMMENT_PARENT_PULL_REQUEST;
+        case -1:
+        case "UNRECOGNIZED":
+        default:
+            return CommentParent.UNRECOGNIZED;
+    }
+}
+function commentParentToJSON(object) {
+    switch (object) {
+        case CommentParent.COMMENT_PARENT_NONE:
+            return "COMMENT_PARENT_NONE";
+        case CommentParent.COMMENT_PARENT_ISSUE:
+            return "COMMENT_PARENT_ISSUE";
+        case CommentParent.COMMENT_PARENT_PULL_REQUEST:
+            return "COMMENT_PARENT_PULL_REQUEST";
+        case CommentParent.UNRECOGNIZED:
+        default:
+            return "UNRECOGNIZED";
+    }
+}
+function createBaseComment() {
+    return {
+        creator: "",
+        id: BigInt(0),
+        repositoryId: BigInt(0),
+        parentIid: BigInt(0),
+        parent: 0,
+        commentIid: BigInt(0),
+        body: "",
+        attachments: [],
+        diffHunk: "",
+        path: "",
+        position: BigInt(0),
+        system: false,
+        authorAssociation: "",
+        createdAt: BigInt(0),
+        updatedAt: BigInt(0),
+        commentType: 0,
+        resolved: false,
+        replies: [],
+        reactions: [],
+        hidden: false
+    };
+}
+exports.Comment = {
+    typeUrl: "/gitopia.gitopia.gitopia.Comment",
+    encode(message, writer = binary_1.BinaryWriter.create()) {
+        if (message.creator !== "") {
+            writer.uint32(10).string(message.creator);
+        }
+        if (message.id !== BigInt(0)) {
+            writer.uint32(16).uint64(message.id);
+        }
+        if (message.repositoryId !== BigInt(0)) {
+            writer.uint32(24).uint64(message.repositoryId);
+        }
+        if (message.parentIid !== BigInt(0)) {
+            writer.uint32(32).uint64(message.parentIid);
+        }
+        if (message.parent !== 0) {
+            writer.uint32(40).int32(message.parent);
+        }
+        if (message.commentIid !== BigInt(0)) {
+            writer.uint32(48).uint64(message.commentIid);
+        }
+        if (message.body !== "") {
+            writer.uint32(58).string(message.body);
+        }
+        for (const v of message.attachments) {
+            attachment_1.Attachment.encode(v, writer.uint32(66).fork()).ldelim();
+        }
+        if (message.diffHunk !== "") {
+            writer.uint32(74).string(message.diffHunk);
+        }
+        if (message.path !== "") {
+            writer.uint32(82).string(message.path);
+        }
+        if (message.position !== BigInt(0)) {
+            writer.uint32(88).uint64(message.position);
+        }
+        if (message.system === true) {
+            writer.uint32(96).bool(message.system);
+        }
+        if (message.authorAssociation !== "") {
+            writer.uint32(106).string(message.authorAssociation);
+        }
+        if (message.createdAt !== BigInt(0)) {
+            writer.uint32(112).int64(message.createdAt);
+        }
+        if (message.updatedAt !== BigInt(0)) {
+            writer.uint32(120).int64(message.updatedAt);
+        }
+        if (message.commentType !== 0) {
+            writer.uint32(128).int32(message.commentType);
+        }
+        if (message.resolved === true) {
+            writer.uint32(136).bool(message.resolved);
+        }
+        writer.uint32(146).fork();
+        for (const v of message.replies) {
+            writer.uint64(v);
+        }
+        writer.ldelim();
+        for (const v of message.reactions) {
+            reaction_1.Reaction.encode(v, writer.uint32(154).fork()).ldelim();
+        }
+        if (message.hidden === true) {
+            writer.uint32(160).bool(message.hidden);
+        }
+        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 = createBaseComment();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.creator = reader.string();
+                    break;
+                case 2:
+                    message.id = reader.uint64();
+                    break;
+                case 3:
+                    message.repositoryId = reader.uint64();
+                    break;
+                case 4:
+                    message.parentIid = reader.uint64();
+                    break;
+                case 5:
+                    message.parent = reader.int32();
+                    break;
+                case 6:
+                    message.commentIid = reader.uint64();
+                    break;
+                case 7:
+                    message.body = reader.string();
+                    break;
+                case 8:
+                    message.attachments.push(attachment_1.Attachment.decode(reader, reader.uint32()));
+                    break;
+                case 9:
+                    message.diffHunk = reader.string();
+                    break;
+                case 10:
+                    message.path = reader.string();
+                    break;
+                case 11:
+                    message.position = reader.uint64();
+                    break;
+                case 12:
+                    message.system = reader.bool();
+                    break;
+                case 13:
+                    message.authorAssociation = reader.string();
+                    break;
+                case 14:
+                    message.createdAt = reader.int64();
+                    break;
+                case 15:
+                    message.updatedAt = reader.int64();
+                    break;
+                case 16:
+                    message.commentType = reader.int32();
+                    break;
+                case 17:
+                    message.resolved = reader.bool();
+                    break;
+                case 18:
+                    if ((tag & 7) === 2) {
+                        const end2 = reader.uint32() + reader.pos;
+                        while (reader.pos < end2) {
+                            message.replies.push(reader.uint64());
+                        }
+                    }
+                    else {
+                        message.replies.push(reader.uint64());
+                    }
+                    break;
+                case 19:
+                    message.reactions.push(reaction_1.Reaction.decode(reader, reader.uint32()));
+                    break;
+                case 20:
+                    message.hidden = reader.bool();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseComment();
+        message.creator = object.creator ?? "";
+        message.id = object.id !== undefined && object.id !== null ? BigInt(object.id.toString()) : BigInt(0);
+        message.repositoryId = object.repositoryId !== undefined && object.repositoryId !== null ? BigInt(object.repositoryId.toString()) : BigInt(0);
+        message.parentIid = object.parentIid !== undefined && object.parentIid !== null ? BigInt(object.parentIid.toString()) : BigInt(0);
+        message.parent = object.parent ?? 0;
+        message.commentIid = object.commentIid !== undefined && object.commentIid !== null ? BigInt(object.commentIid.toString()) : BigInt(0);
+        message.body = object.body ?? "";
+        message.attachments = object.attachments?.map(e => attachment_1.Attachment.fromPartial(e)) || [];
+        message.diffHunk = object.diffHunk ?? "";
+        message.path = object.path ?? "";
+        message.position = object.position !== undefined && object.position !== null ? BigInt(object.position.toString()) : BigInt(0);
+        message.system = object.system ?? false;
+        message.authorAssociation = object.authorAssociation ?? "";
+        message.createdAt = object.createdAt !== undefined && object.createdAt !== null ? BigInt(object.createdAt.toString()) : BigInt(0);
+        message.updatedAt = object.updatedAt !== undefined && object.updatedAt !== null ? BigInt(object.updatedAt.toString()) : BigInt(0);
+        message.commentType = object.commentType ?? 0;
+        message.resolved = object.resolved ?? false;
+        message.replies = object.replies?.map(e => BigInt(e.toString())) || [];
+        message.reactions = object.reactions?.map(e => reaction_1.Reaction.fromPartial(e)) || [];
+        message.hidden = object.hidden ?? false;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseComment();
+        if (object.creator !== undefined && object.creator !== null) {
+            message.creator = object.creator;
+        }
+        if (object.id !== undefined && object.id !== null) {
+            message.id = BigInt(object.id);
+        }
+        if (object.repositoryId !== undefined && object.repositoryId !== null) {
+            message.repositoryId = BigInt(object.repositoryId);
+        }
+        if (object.parentIid !== undefined && object.parentIid !== null) {
+            message.parentIid = BigInt(object.parentIid);
+        }
+        if (object.parent !== undefined && object.parent !== null) {
+            message.parent = object.parent;
+        }
+        if (object.commentIid !== undefined && object.commentIid !== null) {
+            message.commentIid = BigInt(object.commentIid);
+        }
+        if (object.body !== undefined && object.body !== null) {
+            message.body = object.body;
+        }
+        message.attachments = object.attachments?.map(e => attachment_1.Attachment.fromAmino(e)) || [];
+        if (object.diffHunk !== undefined && object.diffHunk !== null) {
+            message.diffHunk = object.diffHunk;
+        }
+        if (object.path !== undefined && object.path !== null) {
+            message.path = object.path;
+        }
+        if (object.position !== undefined && object.position !== null) {
+            message.position = BigInt(object.position);
+        }
+        if (object.system !== undefined && object.system !== null) {
+            message.system = object.system;
+        }
+        if (object.authorAssociation !== undefined && object.authorAssociation !== null) {
+            message.authorAssociation = object.authorAssociation;
+        }
+        if (object.createdAt !== undefined && object.createdAt !== null) {
+            message.createdAt = BigInt(object.createdAt);
+        }
+        if (object.updatedAt !== undefined && object.updatedAt !== null) {
+            message.updatedAt = BigInt(object.updatedAt);
+        }
+        if (object.commentType !== undefined && object.commentType !== null) {
+            message.commentType = object.commentType;
+        }
+        if (object.resolved !== undefined && object.resolved !== null) {
+            message.resolved = object.resolved;
+        }
+        message.replies = object.replies?.map(e => BigInt(e)) || [];
+        message.reactions = object.reactions?.map(e => reaction_1.Reaction.fromAmino(e)) || [];
+        if (object.hidden !== undefined && object.hidden !== null) {
+            message.hidden = object.hidden;
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.creator = message.creator === "" ? undefined : message.creator;
+        obj.id = message.id !== BigInt(0) ? message.id?.toString() : undefined;
+        obj.repositoryId = message.repositoryId !== BigInt(0) ? message.repositoryId?.toString() : undefined;
+        obj.parentIid = message.parentIid !== BigInt(0) ? message.parentIid?.toString() : undefined;
+        obj.parent = message.parent === 0 ? undefined : message.parent;
+        obj.commentIid = message.commentIid !== BigInt(0) ? message.commentIid?.toString() : undefined;
+        obj.body = message.body === "" ? undefined : message.body;
+        if (message.attachments) {
+            obj.attachments = message.attachments.map(e => e ? attachment_1.Attachment.toAmino(e) : undefined);
+        }
+        else {
+            obj.attachments = message.attachments;
+        }
+        obj.diffHunk = message.diffHunk === "" ? undefined : message.diffHunk;
+        obj.path = message.path === "" ? undefined : message.path;
+        obj.position = message.position !== BigInt(0) ? message.position?.toString() : undefined;
+        obj.system = message.system === false ? undefined : message.system;
+        obj.authorAssociation = message.authorAssociation === "" ? undefined : message.authorAssociation;
+        obj.createdAt = message.createdAt !== BigInt(0) ? message.createdAt?.toString() : undefined;
+        obj.updatedAt = message.updatedAt !== BigInt(0) ? message.updatedAt?.toString() : undefined;
+        obj.commentType = message.commentType === 0 ? undefined : message.commentType;
+        obj.resolved = message.resolved === false ? undefined : message.resolved;
+        if (message.replies) {
+            obj.replies = message.replies.map(e => e.toString());
+        }
+        else {
+            obj.replies = message.replies;
+        }
+        if (message.reactions) {
+            obj.reactions = message.reactions.map(e => e ? reaction_1.Reaction.toAmino(e) : undefined);
+        }
+        else {
+            obj.reactions = message.reactions;
+        }
+        obj.hidden = message.hidden === false ? undefined : message.hidden;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return exports.Comment.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return exports.Comment.decode(message.value);
+    },
+    toProto(message) {
+        return exports.Comment.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/gitopia.gitopia.gitopia.Comment",
+            value: exports.Comment.encode(message).finish()
+        };
+    }
+};

package/dist/gitopia/gitopia/gitopia/dao.d.ts

@@ -0,0 +1,160 @@
+import { BinaryReader, BinaryWriter } from "../../../binary";
+/** Configuration options for DAO governance */
+export interface DaoConfig {
+    /** Whether pull requests require governance proposal */
+    requirePullRequestProposal: boolean;
+    /** Whether repository deletion requires governance proposal */
+    requireRepositoryDeletionProposal: boolean;
+    /** Whether management of collaborators requires governance proposal */
+    requireCollaboratorProposal: boolean;
+    /** Whether releases requires governance proposal */
+    requireReleaseProposal: boolean;
+}
+export interface DaoConfigProtoMsg {
+    typeUrl: "/gitopia.gitopia.gitopia.DaoConfig";
+    value: Uint8Array;
+}
+/** Configuration options for DAO governance */
+export interface DaoConfigAmino {
+    /** Whether pull requests require governance proposal */
+    require_pull_request_proposal?: boolean;
+    /** Whether repository deletion requires governance proposal */
+    require_repository_deletion_proposal?: boolean;
+    /** Whether management of collaborators requires governance proposal */
+    require_collaborator_proposal?: boolean;
+    /** Whether releases requires governance proposal */
+    require_release_proposal?: boolean;
+}
+export interface DaoConfigAminoMsg {
+    type: "/gitopia.gitopia.gitopia.DaoConfig";
+    value: DaoConfigAmino;
+}
+/** Configuration options for DAO governance */
+export interface DaoConfigSDKType {
+    require_pull_request_proposal: boolean;
+    require_repository_deletion_proposal: boolean;
+    require_collaborator_proposal: boolean;
+    require_release_proposal: boolean;
+}
+export interface Dao {
+    creator: string;
+    id: bigint;
+    address: string;
+    name: string;
+    avatarUrl: string;
+    followers: string[];
+    following: string[];
+    teams: bigint[];
+    location: string;
+    website: string;
+    verified: boolean;
+    description: string;
+    createdAt: bigint;
+    updatedAt: bigint;
+    pinnedRepos: bigint[];
+    /** Group associated with the DAO */
+    groupId: bigint;
+    /** DAO configuration settings */
+    config: DaoConfig;
+}
+export interface DaoProtoMsg {
+    typeUrl: "/gitopia.gitopia.gitopia.Dao";
+    value: Uint8Array;
+}
+export interface DaoAmino {
+    creator?: string;
+    id?: string;
+    address?: string;
+    name?: string;
+    avatarUrl?: string;
+    followers?: string[];
+    following?: string[];
+    teams?: string[];
+    location?: string;
+    website?: string;
+    verified?: boolean;
+    description?: string;
+    createdAt?: string;
+    updatedAt?: string;
+    pinned_repos?: string[];
+    /** Group associated with the DAO */
+    group_id?: string;
+    /** DAO configuration settings */
+    config?: DaoConfigAmino;
+}
+export interface DaoAminoMsg {
+    type: "/gitopia.gitopia.gitopia.Dao";
+    value: DaoAmino;
+}
+export interface DaoSDKType {
+    creator: string;
+    id: bigint;
+    address: string;
+    name: string;
+    avatarUrl: string;
+    followers: string[];
+    following: string[];
+    teams: bigint[];
+    location: string;
+    website: string;
+    verified: boolean;
+    description: string;
+    createdAt: bigint;
+    updatedAt: bigint;
+    pinned_repos: bigint[];
+    group_id: bigint;
+    config: DaoConfigSDKType;
+}
+export interface GroupDao {
+    daoAddress: string;
+}
+export interface GroupDaoProtoMsg {
+    typeUrl: "/gitopia.gitopia.gitopia.GroupDao";
+    value: Uint8Array;
+}
+export interface GroupDaoAmino {
+    dao_address?: string;
+}
+export interface GroupDaoAminoMsg {
+    type: "/gitopia.gitopia.gitopia.GroupDao";
+    value: GroupDaoAmino;
+}
+export interface GroupDaoSDKType {
+    dao_address: string;
+}
+export declare const DaoConfig: {
+    typeUrl: string;
+    encode(message: DaoConfig, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): DaoConfig;
+    fromPartial(object: Partial<DaoConfig>): DaoConfig;
+    fromAmino(object: DaoConfigAmino): DaoConfig;
+    toAmino(message: DaoConfig): DaoConfigAmino;
+    fromAminoMsg(object: DaoConfigAminoMsg): DaoConfig;
+    fromProtoMsg(message: DaoConfigProtoMsg): DaoConfig;
+    toProto(message: DaoConfig): Uint8Array;
+    toProtoMsg(message: DaoConfig): DaoConfigProtoMsg;
+};
+export declare const Dao: {
+    typeUrl: string;
+    encode(message: Dao, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): Dao;
+    fromPartial(object: Partial<Dao>): Dao;
+    fromAmino(object: DaoAmino): Dao;
+    toAmino(message: Dao): DaoAmino;
+    fromAminoMsg(object: DaoAminoMsg): Dao;
+    fromProtoMsg(message: DaoProtoMsg): Dao;
+    toProto(message: Dao): Uint8Array;
+    toProtoMsg(message: Dao): DaoProtoMsg;
+};
+export declare const GroupDao: {
+    typeUrl: string;
+    encode(message: GroupDao, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): GroupDao;
+    fromPartial(object: Partial<GroupDao>): GroupDao;
+    fromAmino(object: GroupDaoAmino): GroupDao;
+    toAmino(message: GroupDao): GroupDaoAmino;
+    fromAminoMsg(object: GroupDaoAminoMsg): GroupDao;
+    fromProtoMsg(message: GroupDaoProtoMsg): GroupDao;
+    toProto(message: GroupDao): Uint8Array;
+    toProtoMsg(message: GroupDao): GroupDaoProtoMsg;
+};