@gitopia/gitopiajs 0.0.2

package/dist/esm/gitopia/gitopia/gitopia/dao.js

@@ -0,0 +1,451 @@
+//@ts-nocheck
+import { BinaryReader, BinaryWriter } from "../../../binary";
+function createBaseDaoConfig() {
+    return {
+        requirePullRequestProposal: false,
+        requireRepositoryDeletionProposal: false,
+        requireCollaboratorProposal: false,
+        requireReleaseProposal: false
+    };
+}
+export const DaoConfig = {
+    typeUrl: "/gitopia.gitopia.gitopia.DaoConfig",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.requirePullRequestProposal === true) {
+            writer.uint32(8).bool(message.requirePullRequestProposal);
+        }
+        if (message.requireRepositoryDeletionProposal === true) {
+            writer.uint32(16).bool(message.requireRepositoryDeletionProposal);
+        }
+        if (message.requireCollaboratorProposal === true) {
+            writer.uint32(24).bool(message.requireCollaboratorProposal);
+        }
+        if (message.requireReleaseProposal === true) {
+            writer.uint32(32).bool(message.requireReleaseProposal);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseDaoConfig();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.requirePullRequestProposal = reader.bool();
+                    break;
+                case 2:
+                    message.requireRepositoryDeletionProposal = reader.bool();
+                    break;
+                case 3:
+                    message.requireCollaboratorProposal = reader.bool();
+                    break;
+                case 4:
+                    message.requireReleaseProposal = reader.bool();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseDaoConfig();
+        message.requirePullRequestProposal = object.requirePullRequestProposal ?? false;
+        message.requireRepositoryDeletionProposal = object.requireRepositoryDeletionProposal ?? false;
+        message.requireCollaboratorProposal = object.requireCollaboratorProposal ?? false;
+        message.requireReleaseProposal = object.requireReleaseProposal ?? false;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseDaoConfig();
+        if (object.require_pull_request_proposal !== undefined && object.require_pull_request_proposal !== null) {
+            message.requirePullRequestProposal = object.require_pull_request_proposal;
+        }
+        if (object.require_repository_deletion_proposal !== undefined && object.require_repository_deletion_proposal !== null) {
+            message.requireRepositoryDeletionProposal = object.require_repository_deletion_proposal;
+        }
+        if (object.require_collaborator_proposal !== undefined && object.require_collaborator_proposal !== null) {
+            message.requireCollaboratorProposal = object.require_collaborator_proposal;
+        }
+        if (object.require_release_proposal !== undefined && object.require_release_proposal !== null) {
+            message.requireReleaseProposal = object.require_release_proposal;
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.require_pull_request_proposal = message.requirePullRequestProposal === false ? undefined : message.requirePullRequestProposal;
+        obj.require_repository_deletion_proposal = message.requireRepositoryDeletionProposal === false ? undefined : message.requireRepositoryDeletionProposal;
+        obj.require_collaborator_proposal = message.requireCollaboratorProposal === false ? undefined : message.requireCollaboratorProposal;
+        obj.require_release_proposal = message.requireReleaseProposal === false ? undefined : message.requireReleaseProposal;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return DaoConfig.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return DaoConfig.decode(message.value);
+    },
+    toProto(message) {
+        return DaoConfig.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/gitopia.gitopia.gitopia.DaoConfig",
+            value: DaoConfig.encode(message).finish()
+        };
+    }
+};
+function createBaseDao() {
+    return {
+        creator: "",
+        id: BigInt(0),
+        address: "",
+        name: "",
+        avatarUrl: "",
+        followers: [],
+        following: [],
+        teams: [],
+        location: "",
+        website: "",
+        verified: false,
+        description: "",
+        createdAt: BigInt(0),
+        updatedAt: BigInt(0),
+        pinnedRepos: [],
+        groupId: BigInt(0),
+        config: DaoConfig.fromPartial({})
+    };
+}
+export const Dao = {
+    typeUrl: "/gitopia.gitopia.gitopia.Dao",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.creator !== "") {
+            writer.uint32(10).string(message.creator);
+        }
+        if (message.id !== BigInt(0)) {
+            writer.uint32(16).uint64(message.id);
+        }
+        if (message.address !== "") {
+            writer.uint32(26).string(message.address);
+        }
+        if (message.name !== "") {
+            writer.uint32(34).string(message.name);
+        }
+        if (message.avatarUrl !== "") {
+            writer.uint32(42).string(message.avatarUrl);
+        }
+        for (const v of message.followers) {
+            writer.uint32(50).string(v);
+        }
+        for (const v of message.following) {
+            writer.uint32(58).string(v);
+        }
+        writer.uint32(66).fork();
+        for (const v of message.teams) {
+            writer.uint64(v);
+        }
+        writer.ldelim();
+        if (message.location !== "") {
+            writer.uint32(74).string(message.location);
+        }
+        if (message.website !== "") {
+            writer.uint32(82).string(message.website);
+        }
+        if (message.verified === true) {
+            writer.uint32(88).bool(message.verified);
+        }
+        if (message.description !== "") {
+            writer.uint32(98).string(message.description);
+        }
+        if (message.createdAt !== BigInt(0)) {
+            writer.uint32(104).int64(message.createdAt);
+        }
+        if (message.updatedAt !== BigInt(0)) {
+            writer.uint32(112).int64(message.updatedAt);
+        }
+        writer.uint32(122).fork();
+        for (const v of message.pinnedRepos) {
+            writer.uint64(v);
+        }
+        writer.ldelim();
+        if (message.groupId !== BigInt(0)) {
+            writer.uint32(128).uint64(message.groupId);
+        }
+        if (message.config !== undefined) {
+            DaoConfig.encode(message.config, writer.uint32(138).fork()).ldelim();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseDao();
+        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.address = reader.string();
+                    break;
+                case 4:
+                    message.name = reader.string();
+                    break;
+                case 5:
+                    message.avatarUrl = reader.string();
+                    break;
+                case 6:
+                    message.followers.push(reader.string());
+                    break;
+                case 7:
+                    message.following.push(reader.string());
+                    break;
+                case 8:
+                    if ((tag & 7) === 2) {
+                        const end2 = reader.uint32() + reader.pos;
+                        while (reader.pos < end2) {
+                            message.teams.push(reader.uint64());
+                        }
+                    }
+                    else {
+                        message.teams.push(reader.uint64());
+                    }
+                    break;
+                case 9:
+                    message.location = reader.string();
+                    break;
+                case 10:
+                    message.website = reader.string();
+                    break;
+                case 11:
+                    message.verified = reader.bool();
+                    break;
+                case 12:
+                    message.description = reader.string();
+                    break;
+                case 13:
+                    message.createdAt = reader.int64();
+                    break;
+                case 14:
+                    message.updatedAt = reader.int64();
+                    break;
+                case 15:
+                    if ((tag & 7) === 2) {
+                        const end2 = reader.uint32() + reader.pos;
+                        while (reader.pos < end2) {
+                            message.pinnedRepos.push(reader.uint64());
+                        }
+                    }
+                    else {
+                        message.pinnedRepos.push(reader.uint64());
+                    }
+                    break;
+                case 16:
+                    message.groupId = reader.uint64();
+                    break;
+                case 17:
+                    message.config = DaoConfig.decode(reader, reader.uint32());
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseDao();
+        message.creator = object.creator ?? "";
+        message.id = object.id !== undefined && object.id !== null ? BigInt(object.id.toString()) : BigInt(0);
+        message.address = object.address ?? "";
+        message.name = object.name ?? "";
+        message.avatarUrl = object.avatarUrl ?? "";
+        message.followers = object.followers?.map(e => e) || [];
+        message.following = object.following?.map(e => e) || [];
+        message.teams = object.teams?.map(e => BigInt(e.toString())) || [];
+        message.location = object.location ?? "";
+        message.website = object.website ?? "";
+        message.verified = object.verified ?? false;
+        message.description = object.description ?? "";
+        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.pinnedRepos = object.pinnedRepos?.map(e => BigInt(e.toString())) || [];
+        message.groupId = object.groupId !== undefined && object.groupId !== null ? BigInt(object.groupId.toString()) : BigInt(0);
+        message.config = object.config !== undefined && object.config !== null ? DaoConfig.fromPartial(object.config) : undefined;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseDao();
+        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.address !== undefined && object.address !== null) {
+            message.address = object.address;
+        }
+        if (object.name !== undefined && object.name !== null) {
+            message.name = object.name;
+        }
+        if (object.avatarUrl !== undefined && object.avatarUrl !== null) {
+            message.avatarUrl = object.avatarUrl;
+        }
+        message.followers = object.followers?.map(e => e) || [];
+        message.following = object.following?.map(e => e) || [];
+        message.teams = object.teams?.map(e => BigInt(e)) || [];
+        if (object.location !== undefined && object.location !== null) {
+            message.location = object.location;
+        }
+        if (object.website !== undefined && object.website !== null) {
+            message.website = object.website;
+        }
+        if (object.verified !== undefined && object.verified !== null) {
+            message.verified = object.verified;
+        }
+        if (object.description !== undefined && object.description !== null) {
+            message.description = object.description;
+        }
+        if (object.createdAt !== undefined && object.createdAt !== null) {
+            message.createdAt = BigInt(object.createdAt);
+        }
+        if (object.updatedAt !== undefined && object.updatedAt !== null) {
+            message.updatedAt = BigInt(object.updatedAt);
+        }
+        message.pinnedRepos = object.pinned_repos?.map(e => BigInt(e)) || [];
+        if (object.group_id !== undefined && object.group_id !== null) {
+            message.groupId = BigInt(object.group_id);
+        }
+        if (object.config !== undefined && object.config !== null) {
+            message.config = DaoConfig.fromAmino(object.config);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.creator = message.creator === "" ? undefined : message.creator;
+        obj.id = message.id !== BigInt(0) ? message.id?.toString() : undefined;
+        obj.address = message.address === "" ? undefined : message.address;
+        obj.name = message.name === "" ? undefined : message.name;
+        obj.avatarUrl = message.avatarUrl === "" ? undefined : message.avatarUrl;
+        if (message.followers) {
+            obj.followers = message.followers.map(e => e);
+        }
+        else {
+            obj.followers = message.followers;
+        }
+        if (message.following) {
+            obj.following = message.following.map(e => e);
+        }
+        else {
+            obj.following = message.following;
+        }
+        if (message.teams) {
+            obj.teams = message.teams.map(e => e.toString());
+        }
+        else {
+            obj.teams = message.teams;
+        }
+        obj.location = message.location === "" ? undefined : message.location;
+        obj.website = message.website === "" ? undefined : message.website;
+        obj.verified = message.verified === false ? undefined : message.verified;
+        obj.description = message.description === "" ? undefined : message.description;
+        obj.createdAt = message.createdAt !== BigInt(0) ? message.createdAt?.toString() : undefined;
+        obj.updatedAt = message.updatedAt !== BigInt(0) ? message.updatedAt?.toString() : undefined;
+        if (message.pinnedRepos) {
+            obj.pinned_repos = message.pinnedRepos.map(e => e.toString());
+        }
+        else {
+            obj.pinned_repos = message.pinnedRepos;
+        }
+        obj.group_id = message.groupId !== BigInt(0) ? message.groupId?.toString() : undefined;
+        obj.config = message.config ? DaoConfig.toAmino(message.config) : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return Dao.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return Dao.decode(message.value);
+    },
+    toProto(message) {
+        return Dao.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/gitopia.gitopia.gitopia.Dao",
+            value: Dao.encode(message).finish()
+        };
+    }
+};
+function createBaseGroupDao() {
+    return {
+        daoAddress: ""
+    };
+}
+export const GroupDao = {
+    typeUrl: "/gitopia.gitopia.gitopia.GroupDao",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.daoAddress !== "") {
+            writer.uint32(10).string(message.daoAddress);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseGroupDao();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.daoAddress = reader.string();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseGroupDao();
+        message.daoAddress = object.daoAddress ?? "";
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseGroupDao();
+        if (object.dao_address !== undefined && object.dao_address !== null) {
+            message.daoAddress = object.dao_address;
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.dao_address = message.daoAddress === "" ? undefined : message.daoAddress;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return GroupDao.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return GroupDao.decode(message.value);
+    },
+    toProto(message) {
+        return GroupDao.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/gitopia.gitopia.gitopia.GroupDao",
+            value: GroupDao.encode(message).finish()
+        };
+    }
+};

package/dist/esm/gitopia/gitopia/gitopia/exercised_amount.js

@@ -0,0 +1,78 @@
+//@ts-nocheck
+import { Coin } from "../../../cosmos/base/v1beta1/coin";
+import { BinaryReader, BinaryWriter } from "../../../binary";
+function createBaseExercisedAmount() {
+    return {
+        address: "",
+        amount: Coin.fromPartial({})
+    };
+}
+export const ExercisedAmount = {
+    typeUrl: "/gitopia.gitopia.gitopia.ExercisedAmount",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.address !== "") {
+            writer.uint32(10).string(message.address);
+        }
+        if (message.amount !== undefined) {
+            Coin.encode(message.amount, writer.uint32(18).fork()).ldelim();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseExercisedAmount();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.address = reader.string();
+                    break;
+                case 2:
+                    message.amount = Coin.decode(reader, reader.uint32());
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseExercisedAmount();
+        message.address = object.address ?? "";
+        message.amount = object.amount !== undefined && object.amount !== null ? Coin.fromPartial(object.amount) : undefined;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseExercisedAmount();
+        if (object.address !== undefined && object.address !== null) {
+            message.address = object.address;
+        }
+        if (object.amount !== undefined && object.amount !== null) {
+            message.amount = Coin.fromAmino(object.amount);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.address = message.address === "" ? undefined : message.address;
+        obj.amount = message.amount ? Coin.toAmino(message.amount) : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return ExercisedAmount.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return ExercisedAmount.decode(message.value);
+    },
+    toProto(message) {
+        return ExercisedAmount.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/gitopia.gitopia.gitopia.ExercisedAmount",
+            value: ExercisedAmount.encode(message).finish()
+        };
+    }
+};