@gitopia/gitopiajs 0.0.4 → 0.0.6

package/dist/cosmos/group/v1/query.lcd.d.ts

@@ -0,0 +1,22 @@
+import { LCDClient } from "@cosmology/lcd";
+import { QueryGroupInfoRequest, QueryGroupInfoResponseSDKType, QueryGroupPolicyInfoRequest, QueryGroupPolicyInfoResponseSDKType, QueryGroupMembersRequest, QueryGroupMembersResponseSDKType, QueryGroupsByAdminRequest, QueryGroupsByAdminResponseSDKType, QueryGroupPoliciesByGroupRequest, QueryGroupPoliciesByGroupResponseSDKType, QueryGroupPoliciesByAdminRequest, QueryGroupPoliciesByAdminResponseSDKType, QueryProposalRequest, QueryProposalResponseSDKType, QueryProposalsByGroupPolicyRequest, QueryProposalsByGroupPolicyResponseSDKType, QueryVoteByProposalVoterRequest, QueryVoteByProposalVoterResponseSDKType, QueryVotesByProposalRequest, QueryVotesByProposalResponseSDKType, QueryVotesByVoterRequest, QueryVotesByVoterResponseSDKType, QueryGroupsByMemberRequest, QueryGroupsByMemberResponseSDKType, QueryTallyResultRequest, QueryTallyResultResponseSDKType, QueryGroupsRequest, QueryGroupsResponseSDKType } from "./query";
+export declare class LCDQueryClient {
+    req: LCDClient;
+    constructor({ requestClient }: {
+        requestClient: LCDClient;
+    });
+    groupInfo(params: QueryGroupInfoRequest): Promise<QueryGroupInfoResponseSDKType>;
+    groupPolicyInfo(params: QueryGroupPolicyInfoRequest): Promise<QueryGroupPolicyInfoResponseSDKType>;
+    groupMembers(params: QueryGroupMembersRequest): Promise<QueryGroupMembersResponseSDKType>;
+    groupsByAdmin(params: QueryGroupsByAdminRequest): Promise<QueryGroupsByAdminResponseSDKType>;
+    groupPoliciesByGroup(params: QueryGroupPoliciesByGroupRequest): Promise<QueryGroupPoliciesByGroupResponseSDKType>;
+    groupPoliciesByAdmin(params: QueryGroupPoliciesByAdminRequest): Promise<QueryGroupPoliciesByAdminResponseSDKType>;
+    proposal(params: QueryProposalRequest): Promise<QueryProposalResponseSDKType>;
+    proposalsByGroupPolicy(params: QueryProposalsByGroupPolicyRequest): Promise<QueryProposalsByGroupPolicyResponseSDKType>;
+    voteByProposalVoter(params: QueryVoteByProposalVoterRequest): Promise<QueryVoteByProposalVoterResponseSDKType>;
+    votesByProposal(params: QueryVotesByProposalRequest): Promise<QueryVotesByProposalResponseSDKType>;
+    votesByVoter(params: QueryVotesByVoterRequest): Promise<QueryVotesByVoterResponseSDKType>;
+    groupsByMember(params: QueryGroupsByMemberRequest): Promise<QueryGroupsByMemberResponseSDKType>;
+    tallyResult(params: QueryTallyResultRequest): Promise<QueryTallyResultResponseSDKType>;
+    groups(params?: QueryGroupsRequest): Promise<QueryGroupsResponseSDKType>;
+}

package/dist/cosmos/group/v1/query.lcd.js

@@ -0,0 +1,158 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LCDQueryClient = void 0;
+//@ts-nocheck
+const helpers_1 = require("../../../helpers");
+class LCDQueryClient {
+    req;
+    constructor({ requestClient }) {
+        this.req = requestClient;
+        this.groupInfo = this.groupInfo.bind(this);
+        this.groupPolicyInfo = this.groupPolicyInfo.bind(this);
+        this.groupMembers = this.groupMembers.bind(this);
+        this.groupsByAdmin = this.groupsByAdmin.bind(this);
+        this.groupPoliciesByGroup = this.groupPoliciesByGroup.bind(this);
+        this.groupPoliciesByAdmin = this.groupPoliciesByAdmin.bind(this);
+        this.proposal = this.proposal.bind(this);
+        this.proposalsByGroupPolicy = this.proposalsByGroupPolicy.bind(this);
+        this.voteByProposalVoter = this.voteByProposalVoter.bind(this);
+        this.votesByProposal = this.votesByProposal.bind(this);
+        this.votesByVoter = this.votesByVoter.bind(this);
+        this.groupsByMember = this.groupsByMember.bind(this);
+        this.tallyResult = this.tallyResult.bind(this);
+        this.groups = this.groups.bind(this);
+    }
+    /* GroupInfo queries group info based on group id. */
+    async groupInfo(params) {
+        const endpoint = `cosmos/group/v1/group_info/${params.groupId}`;
+        return await this.req.get(endpoint);
+    }
+    /* GroupPolicyInfo queries group policy info based on account address of group policy. */
+    async groupPolicyInfo(params) {
+        const endpoint = `cosmos/group/v1/group_policy_info/${params.address}`;
+        return await this.req.get(endpoint);
+    }
+    /* GroupMembers queries members of a group by group id. */
+    async groupMembers(params) {
+        const options = {
+            params: {}
+        };
+        if (typeof params?.pagination !== "undefined") {
+            (0, helpers_1.setPaginationParams)(options, params.pagination);
+        }
+        const endpoint = `cosmos/group/v1/group_members/${params.groupId}`;
+        return await this.req.get(endpoint, options);
+    }
+    /* GroupsByAdmin queries groups by admin address. */
+    async groupsByAdmin(params) {
+        const options = {
+            params: {}
+        };
+        if (typeof params?.pagination !== "undefined") {
+            (0, helpers_1.setPaginationParams)(options, params.pagination);
+        }
+        const endpoint = `cosmos/group/v1/groups_by_admin/${params.admin}`;
+        return await this.req.get(endpoint, options);
+    }
+    /* GroupPoliciesByGroup queries group policies by group id. */
+    async groupPoliciesByGroup(params) {
+        const options = {
+            params: {}
+        };
+        if (typeof params?.pagination !== "undefined") {
+            (0, helpers_1.setPaginationParams)(options, params.pagination);
+        }
+        const endpoint = `cosmos/group/v1/group_policies_by_group/${params.groupId}`;
+        return await this.req.get(endpoint, options);
+    }
+    /* GroupPoliciesByAdmin queries group policies by admin address. */
+    async groupPoliciesByAdmin(params) {
+        const options = {
+            params: {}
+        };
+        if (typeof params?.pagination !== "undefined") {
+            (0, helpers_1.setPaginationParams)(options, params.pagination);
+        }
+        const endpoint = `cosmos/group/v1/group_policies_by_admin/${params.admin}`;
+        return await this.req.get(endpoint, options);
+    }
+    /* Proposal queries a proposal based on proposal id. */
+    async proposal(params) {
+        const endpoint = `cosmos/group/v1/proposal/${params.proposalId}`;
+        return await this.req.get(endpoint);
+    }
+    /* ProposalsByGroupPolicy queries proposals based on account address of group policy. */
+    async proposalsByGroupPolicy(params) {
+        const options = {
+            params: {}
+        };
+        if (typeof params?.pagination !== "undefined") {
+            (0, helpers_1.setPaginationParams)(options, params.pagination);
+        }
+        const endpoint = `cosmos/group/v1/proposals_by_group_policy/${params.address}`;
+        return await this.req.get(endpoint, options);
+    }
+    /* VoteByProposalVoter queries a vote by proposal id and voter. */
+    async voteByProposalVoter(params) {
+        const endpoint = `cosmos/group/v1/vote_by_proposal_voter/${params.proposalId}/${params.voter}`;
+        return await this.req.get(endpoint);
+    }
+    /* VotesByProposal queries a vote by proposal id. */
+    async votesByProposal(params) {
+        const options = {
+            params: {}
+        };
+        if (typeof params?.pagination !== "undefined") {
+            (0, helpers_1.setPaginationParams)(options, params.pagination);
+        }
+        const endpoint = `cosmos/group/v1/votes_by_proposal/${params.proposalId}`;
+        return await this.req.get(endpoint, options);
+    }
+    /* VotesByVoter queries a vote by voter. */
+    async votesByVoter(params) {
+        const options = {
+            params: {}
+        };
+        if (typeof params?.pagination !== "undefined") {
+            (0, helpers_1.setPaginationParams)(options, params.pagination);
+        }
+        const endpoint = `cosmos/group/v1/votes_by_voter/${params.voter}`;
+        return await this.req.get(endpoint, options);
+    }
+    /* GroupsByMember queries groups by member address. */
+    async groupsByMember(params) {
+        const options = {
+            params: {}
+        };
+        if (typeof params?.pagination !== "undefined") {
+            (0, helpers_1.setPaginationParams)(options, params.pagination);
+        }
+        const endpoint = `cosmos/group/v1/groups_by_member/${params.address}`;
+        return await this.req.get(endpoint, options);
+    }
+    /* TallyResult returns the tally result of a proposal. If the proposal is
+     still in voting period, then this query computes the current tally state,
+     which might not be final. On the other hand, if the proposal is final,
+     then it simply returns the `final_tally_result` state stored in the
+     proposal itself. */
+    async tallyResult(params) {
+        const endpoint = `cosmos/group/v1/proposals/${params.proposalId}/tally`;
+        return await this.req.get(endpoint);
+    }
+    /* Groups queries all groups in state.
+    
+     Since: cosmos-sdk 0.47.1 */
+    async groups(params = {
+        pagination: undefined
+    }) {
+        const options = {
+            params: {}
+        };
+        if (typeof params?.pagination !== "undefined") {
+            (0, helpers_1.setPaginationParams)(options, params.pagination);
+        }
+        const endpoint = `cosmos/group/v1/groups`;
+        return await this.req.get(endpoint, options);
+    }
+}
+exports.LCDQueryClient = LCDQueryClient;

package/dist/cosmos/group/v1/query.rpc.Query.d.ts

@@ -0,0 +1,78 @@
+import { Rpc } from "../../../helpers";
+import { QueryClient } from "@cosmjs/stargate";
+import { QueryGroupInfoRequest, QueryGroupInfoResponse, QueryGroupPolicyInfoRequest, QueryGroupPolicyInfoResponse, QueryGroupMembersRequest, QueryGroupMembersResponse, QueryGroupsByAdminRequest, QueryGroupsByAdminResponse, QueryGroupPoliciesByGroupRequest, QueryGroupPoliciesByGroupResponse, QueryGroupPoliciesByAdminRequest, QueryGroupPoliciesByAdminResponse, QueryProposalRequest, QueryProposalResponse, QueryProposalsByGroupPolicyRequest, QueryProposalsByGroupPolicyResponse, QueryVoteByProposalVoterRequest, QueryVoteByProposalVoterResponse, QueryVotesByProposalRequest, QueryVotesByProposalResponse, QueryVotesByVoterRequest, QueryVotesByVoterResponse, QueryGroupsByMemberRequest, QueryGroupsByMemberResponse, QueryTallyResultRequest, QueryTallyResultResponse, QueryGroupsRequest, QueryGroupsResponse } from "./query";
+/** Query is the cosmos.group.v1 Query service. */
+export interface Query {
+    /** GroupInfo queries group info based on group id. */
+    groupInfo(request: QueryGroupInfoRequest): Promise<QueryGroupInfoResponse>;
+    /** GroupPolicyInfo queries group policy info based on account address of group policy. */
+    groupPolicyInfo(request: QueryGroupPolicyInfoRequest): Promise<QueryGroupPolicyInfoResponse>;
+    /** GroupMembers queries members of a group by group id. */
+    groupMembers(request: QueryGroupMembersRequest): Promise<QueryGroupMembersResponse>;
+    /** GroupsByAdmin queries groups by admin address. */
+    groupsByAdmin(request: QueryGroupsByAdminRequest): Promise<QueryGroupsByAdminResponse>;
+    /** GroupPoliciesByGroup queries group policies by group id. */
+    groupPoliciesByGroup(request: QueryGroupPoliciesByGroupRequest): Promise<QueryGroupPoliciesByGroupResponse>;
+    /** GroupPoliciesByAdmin queries group policies by admin address. */
+    groupPoliciesByAdmin(request: QueryGroupPoliciesByAdminRequest): Promise<QueryGroupPoliciesByAdminResponse>;
+    /** Proposal queries a proposal based on proposal id. */
+    proposal(request: QueryProposalRequest): Promise<QueryProposalResponse>;
+    /** ProposalsByGroupPolicy queries proposals based on account address of group policy. */
+    proposalsByGroupPolicy(request: QueryProposalsByGroupPolicyRequest): Promise<QueryProposalsByGroupPolicyResponse>;
+    /** VoteByProposalVoter queries a vote by proposal id and voter. */
+    voteByProposalVoter(request: QueryVoteByProposalVoterRequest): Promise<QueryVoteByProposalVoterResponse>;
+    /** VotesByProposal queries a vote by proposal id. */
+    votesByProposal(request: QueryVotesByProposalRequest): Promise<QueryVotesByProposalResponse>;
+    /** VotesByVoter queries a vote by voter. */
+    votesByVoter(request: QueryVotesByVoterRequest): Promise<QueryVotesByVoterResponse>;
+    /** GroupsByMember queries groups by member address. */
+    groupsByMember(request: QueryGroupsByMemberRequest): Promise<QueryGroupsByMemberResponse>;
+    /**
+     * TallyResult returns the tally result of a proposal. If the proposal is
+     * still in voting period, then this query computes the current tally state,
+     * which might not be final. On the other hand, if the proposal is final,
+     * then it simply returns the `final_tally_result` state stored in the
+     * proposal itself.
+     */
+    tallyResult(request: QueryTallyResultRequest): Promise<QueryTallyResultResponse>;
+    /**
+     * Groups queries all groups in state.
+     *
+     * Since: cosmos-sdk 0.47.1
+     */
+    groups(request?: QueryGroupsRequest): Promise<QueryGroupsResponse>;
+}
+export declare class QueryClientImpl implements Query {
+    private readonly rpc;
+    constructor(rpc: Rpc);
+    groupInfo(request: QueryGroupInfoRequest): Promise<QueryGroupInfoResponse>;
+    groupPolicyInfo(request: QueryGroupPolicyInfoRequest): Promise<QueryGroupPolicyInfoResponse>;
+    groupMembers(request: QueryGroupMembersRequest): Promise<QueryGroupMembersResponse>;
+    groupsByAdmin(request: QueryGroupsByAdminRequest): Promise<QueryGroupsByAdminResponse>;
+    groupPoliciesByGroup(request: QueryGroupPoliciesByGroupRequest): Promise<QueryGroupPoliciesByGroupResponse>;
+    groupPoliciesByAdmin(request: QueryGroupPoliciesByAdminRequest): Promise<QueryGroupPoliciesByAdminResponse>;
+    proposal(request: QueryProposalRequest): Promise<QueryProposalResponse>;
+    proposalsByGroupPolicy(request: QueryProposalsByGroupPolicyRequest): Promise<QueryProposalsByGroupPolicyResponse>;
+    voteByProposalVoter(request: QueryVoteByProposalVoterRequest): Promise<QueryVoteByProposalVoterResponse>;
+    votesByProposal(request: QueryVotesByProposalRequest): Promise<QueryVotesByProposalResponse>;
+    votesByVoter(request: QueryVotesByVoterRequest): Promise<QueryVotesByVoterResponse>;
+    groupsByMember(request: QueryGroupsByMemberRequest): Promise<QueryGroupsByMemberResponse>;
+    tallyResult(request: QueryTallyResultRequest): Promise<QueryTallyResultResponse>;
+    groups(request?: QueryGroupsRequest): Promise<QueryGroupsResponse>;
+}
+export declare const createRpcQueryExtension: (base: QueryClient) => {
+    groupInfo(request: QueryGroupInfoRequest): Promise<QueryGroupInfoResponse>;
+    groupPolicyInfo(request: QueryGroupPolicyInfoRequest): Promise<QueryGroupPolicyInfoResponse>;
+    groupMembers(request: QueryGroupMembersRequest): Promise<QueryGroupMembersResponse>;
+    groupsByAdmin(request: QueryGroupsByAdminRequest): Promise<QueryGroupsByAdminResponse>;
+    groupPoliciesByGroup(request: QueryGroupPoliciesByGroupRequest): Promise<QueryGroupPoliciesByGroupResponse>;
+    groupPoliciesByAdmin(request: QueryGroupPoliciesByAdminRequest): Promise<QueryGroupPoliciesByAdminResponse>;
+    proposal(request: QueryProposalRequest): Promise<QueryProposalResponse>;
+    proposalsByGroupPolicy(request: QueryProposalsByGroupPolicyRequest): Promise<QueryProposalsByGroupPolicyResponse>;
+    voteByProposalVoter(request: QueryVoteByProposalVoterRequest): Promise<QueryVoteByProposalVoterResponse>;
+    votesByProposal(request: QueryVotesByProposalRequest): Promise<QueryVotesByProposalResponse>;
+    votesByVoter(request: QueryVotesByVoterRequest): Promise<QueryVotesByVoterResponse>;
+    groupsByMember(request: QueryGroupsByMemberRequest): Promise<QueryGroupsByMemberResponse>;
+    tallyResult(request: QueryTallyResultRequest): Promise<QueryTallyResultResponse>;
+    groups(request?: QueryGroupsRequest): Promise<QueryGroupsResponse>;
+};

package/dist/cosmos/group/v1/query.rpc.Query.js

@@ -0,0 +1,148 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createRpcQueryExtension = exports.QueryClientImpl = void 0;
+const binary_1 = require("../../../binary");
+const stargate_1 = require("@cosmjs/stargate");
+const query_1 = require("./query");
+class QueryClientImpl {
+    rpc;
+    constructor(rpc) {
+        this.rpc = rpc;
+        this.groupInfo = this.groupInfo.bind(this);
+        this.groupPolicyInfo = this.groupPolicyInfo.bind(this);
+        this.groupMembers = this.groupMembers.bind(this);
+        this.groupsByAdmin = this.groupsByAdmin.bind(this);
+        this.groupPoliciesByGroup = this.groupPoliciesByGroup.bind(this);
+        this.groupPoliciesByAdmin = this.groupPoliciesByAdmin.bind(this);
+        this.proposal = this.proposal.bind(this);
+        this.proposalsByGroupPolicy = this.proposalsByGroupPolicy.bind(this);
+        this.voteByProposalVoter = this.voteByProposalVoter.bind(this);
+        this.votesByProposal = this.votesByProposal.bind(this);
+        this.votesByVoter = this.votesByVoter.bind(this);
+        this.groupsByMember = this.groupsByMember.bind(this);
+        this.tallyResult = this.tallyResult.bind(this);
+        this.groups = this.groups.bind(this);
+    }
+    groupInfo(request) {
+        const data = query_1.QueryGroupInfoRequest.encode(request).finish();
+        const promise = this.rpc.request("cosmos.group.v1.Query", "GroupInfo", data);
+        return promise.then(data => query_1.QueryGroupInfoResponse.decode(new binary_1.BinaryReader(data)));
+    }
+    groupPolicyInfo(request) {
+        const data = query_1.QueryGroupPolicyInfoRequest.encode(request).finish();
+        const promise = this.rpc.request("cosmos.group.v1.Query", "GroupPolicyInfo", data);
+        return promise.then(data => query_1.QueryGroupPolicyInfoResponse.decode(new binary_1.BinaryReader(data)));
+    }
+    groupMembers(request) {
+        const data = query_1.QueryGroupMembersRequest.encode(request).finish();
+        const promise = this.rpc.request("cosmos.group.v1.Query", "GroupMembers", data);
+        return promise.then(data => query_1.QueryGroupMembersResponse.decode(new binary_1.BinaryReader(data)));
+    }
+    groupsByAdmin(request) {
+        const data = query_1.QueryGroupsByAdminRequest.encode(request).finish();
+        const promise = this.rpc.request("cosmos.group.v1.Query", "GroupsByAdmin", data);
+        return promise.then(data => query_1.QueryGroupsByAdminResponse.decode(new binary_1.BinaryReader(data)));
+    }
+    groupPoliciesByGroup(request) {
+        const data = query_1.QueryGroupPoliciesByGroupRequest.encode(request).finish();
+        const promise = this.rpc.request("cosmos.group.v1.Query", "GroupPoliciesByGroup", data);
+        return promise.then(data => query_1.QueryGroupPoliciesByGroupResponse.decode(new binary_1.BinaryReader(data)));
+    }
+    groupPoliciesByAdmin(request) {
+        const data = query_1.QueryGroupPoliciesByAdminRequest.encode(request).finish();
+        const promise = this.rpc.request("cosmos.group.v1.Query", "GroupPoliciesByAdmin", data);
+        return promise.then(data => query_1.QueryGroupPoliciesByAdminResponse.decode(new binary_1.BinaryReader(data)));
+    }
+    proposal(request) {
+        const data = query_1.QueryProposalRequest.encode(request).finish();
+        const promise = this.rpc.request("cosmos.group.v1.Query", "Proposal", data);
+        return promise.then(data => query_1.QueryProposalResponse.decode(new binary_1.BinaryReader(data)));
+    }
+    proposalsByGroupPolicy(request) {
+        const data = query_1.QueryProposalsByGroupPolicyRequest.encode(request).finish();
+        const promise = this.rpc.request("cosmos.group.v1.Query", "ProposalsByGroupPolicy", data);
+        return promise.then(data => query_1.QueryProposalsByGroupPolicyResponse.decode(new binary_1.BinaryReader(data)));
+    }
+    voteByProposalVoter(request) {
+        const data = query_1.QueryVoteByProposalVoterRequest.encode(request).finish();
+        const promise = this.rpc.request("cosmos.group.v1.Query", "VoteByProposalVoter", data);
+        return promise.then(data => query_1.QueryVoteByProposalVoterResponse.decode(new binary_1.BinaryReader(data)));
+    }
+    votesByProposal(request) {
+        const data = query_1.QueryVotesByProposalRequest.encode(request).finish();
+        const promise = this.rpc.request("cosmos.group.v1.Query", "VotesByProposal", data);
+        return promise.then(data => query_1.QueryVotesByProposalResponse.decode(new binary_1.BinaryReader(data)));
+    }
+    votesByVoter(request) {
+        const data = query_1.QueryVotesByVoterRequest.encode(request).finish();
+        const promise = this.rpc.request("cosmos.group.v1.Query", "VotesByVoter", data);
+        return promise.then(data => query_1.QueryVotesByVoterResponse.decode(new binary_1.BinaryReader(data)));
+    }
+    groupsByMember(request) {
+        const data = query_1.QueryGroupsByMemberRequest.encode(request).finish();
+        const promise = this.rpc.request("cosmos.group.v1.Query", "GroupsByMember", data);
+        return promise.then(data => query_1.QueryGroupsByMemberResponse.decode(new binary_1.BinaryReader(data)));
+    }
+    tallyResult(request) {
+        const data = query_1.QueryTallyResultRequest.encode(request).finish();
+        const promise = this.rpc.request("cosmos.group.v1.Query", "TallyResult", data);
+        return promise.then(data => query_1.QueryTallyResultResponse.decode(new binary_1.BinaryReader(data)));
+    }
+    groups(request = {
+        pagination: undefined
+    }) {
+        const data = query_1.QueryGroupsRequest.encode(request).finish();
+        const promise = this.rpc.request("cosmos.group.v1.Query", "Groups", data);
+        return promise.then(data => query_1.QueryGroupsResponse.decode(new binary_1.BinaryReader(data)));
+    }
+}
+exports.QueryClientImpl = QueryClientImpl;
+const createRpcQueryExtension = (base) => {
+    const rpc = (0, stargate_1.createProtobufRpcClient)(base);
+    const queryService = new QueryClientImpl(rpc);
+    return {
+        groupInfo(request) {
+            return queryService.groupInfo(request);
+        },
+        groupPolicyInfo(request) {
+            return queryService.groupPolicyInfo(request);
+        },
+        groupMembers(request) {
+            return queryService.groupMembers(request);
+        },
+        groupsByAdmin(request) {
+            return queryService.groupsByAdmin(request);
+        },
+        groupPoliciesByGroup(request) {
+            return queryService.groupPoliciesByGroup(request);
+        },
+        groupPoliciesByAdmin(request) {
+            return queryService.groupPoliciesByAdmin(request);
+        },
+        proposal(request) {
+            return queryService.proposal(request);
+        },
+        proposalsByGroupPolicy(request) {
+            return queryService.proposalsByGroupPolicy(request);
+        },
+        voteByProposalVoter(request) {
+            return queryService.voteByProposalVoter(request);
+        },
+        votesByProposal(request) {
+            return queryService.votesByProposal(request);
+        },
+        votesByVoter(request) {
+            return queryService.votesByVoter(request);
+        },
+        groupsByMember(request) {
+            return queryService.groupsByMember(request);
+        },
+        tallyResult(request) {
+            return queryService.tallyResult(request);
+        },
+        groups(request) {
+            return queryService.groups(request);
+        }
+    };
+};
+exports.createRpcQueryExtension = createRpcQueryExtension;

package/dist/cosmos/group/v1/tx.amino.d.ts

@@ -0,0 +1,73 @@
+import { MsgCreateGroup, MsgUpdateGroupMembers, MsgUpdateGroupAdmin, MsgUpdateGroupMetadata, MsgCreateGroupPolicy, MsgCreateGroupWithPolicy, MsgUpdateGroupPolicyAdmin, MsgUpdateGroupPolicyDecisionPolicy, MsgUpdateGroupPolicyMetadata, MsgSubmitProposal, MsgWithdrawProposal, MsgVote, MsgExec, MsgLeaveGroup } from "./tx";
+export declare const AminoConverter: {
+    "/cosmos.group.v1.MsgCreateGroup": {
+        aminoType: string;
+        toAmino: (message: MsgCreateGroup) => import("./tx").MsgCreateGroupAmino;
+        fromAmino: (object: import("./tx").MsgCreateGroupAmino) => MsgCreateGroup;
+    };
+    "/cosmos.group.v1.MsgUpdateGroupMembers": {
+        aminoType: string;
+        toAmino: (message: MsgUpdateGroupMembers) => import("./tx").MsgUpdateGroupMembersAmino;
+        fromAmino: (object: import("./tx").MsgUpdateGroupMembersAmino) => MsgUpdateGroupMembers;
+    };
+    "/cosmos.group.v1.MsgUpdateGroupAdmin": {
+        aminoType: string;
+        toAmino: (message: MsgUpdateGroupAdmin) => import("./tx").MsgUpdateGroupAdminAmino;
+        fromAmino: (object: import("./tx").MsgUpdateGroupAdminAmino) => MsgUpdateGroupAdmin;
+    };
+    "/cosmos.group.v1.MsgUpdateGroupMetadata": {
+        aminoType: string;
+        toAmino: (message: MsgUpdateGroupMetadata) => import("./tx").MsgUpdateGroupMetadataAmino;
+        fromAmino: (object: import("./tx").MsgUpdateGroupMetadataAmino) => MsgUpdateGroupMetadata;
+    };
+    "/cosmos.group.v1.MsgCreateGroupPolicy": {
+        aminoType: string;
+        toAmino: (message: MsgCreateGroupPolicy) => import("./tx").MsgCreateGroupPolicyAmino;
+        fromAmino: (object: import("./tx").MsgCreateGroupPolicyAmino) => MsgCreateGroupPolicy;
+    };
+    "/cosmos.group.v1.MsgCreateGroupWithPolicy": {
+        aminoType: string;
+        toAmino: (message: MsgCreateGroupWithPolicy) => import("./tx").MsgCreateGroupWithPolicyAmino;
+        fromAmino: (object: import("./tx").MsgCreateGroupWithPolicyAmino) => MsgCreateGroupWithPolicy;
+    };
+    "/cosmos.group.v1.MsgUpdateGroupPolicyAdmin": {
+        aminoType: string;
+        toAmino: (message: MsgUpdateGroupPolicyAdmin) => import("./tx").MsgUpdateGroupPolicyAdminAmino;
+        fromAmino: (object: import("./tx").MsgUpdateGroupPolicyAdminAmino) => MsgUpdateGroupPolicyAdmin;
+    };
+    "/cosmos.group.v1.MsgUpdateGroupPolicyDecisionPolicy": {
+        aminoType: string;
+        toAmino: (message: MsgUpdateGroupPolicyDecisionPolicy) => import("./tx").MsgUpdateGroupPolicyDecisionPolicyAmino;
+        fromAmino: (object: import("./tx").MsgUpdateGroupPolicyDecisionPolicyAmino) => MsgUpdateGroupPolicyDecisionPolicy;
+    };
+    "/cosmos.group.v1.MsgUpdateGroupPolicyMetadata": {
+        aminoType: string;
+        toAmino: (message: MsgUpdateGroupPolicyMetadata) => import("./tx").MsgUpdateGroupPolicyMetadataAmino;
+        fromAmino: (object: import("./tx").MsgUpdateGroupPolicyMetadataAmino) => MsgUpdateGroupPolicyMetadata;
+    };
+    "/cosmos.group.v1.MsgSubmitProposal": {
+        aminoType: string;
+        toAmino: (message: MsgSubmitProposal) => import("./tx").MsgSubmitProposalAmino;
+        fromAmino: (object: import("./tx").MsgSubmitProposalAmino) => MsgSubmitProposal;
+    };
+    "/cosmos.group.v1.MsgWithdrawProposal": {
+        aminoType: string;
+        toAmino: (message: MsgWithdrawProposal) => import("./tx").MsgWithdrawProposalAmino;
+        fromAmino: (object: import("./tx").MsgWithdrawProposalAmino) => MsgWithdrawProposal;
+    };
+    "/cosmos.group.v1.MsgVote": {
+        aminoType: string;
+        toAmino: (message: MsgVote) => import("./tx").MsgVoteAmino;
+        fromAmino: (object: import("./tx").MsgVoteAmino) => MsgVote;
+    };
+    "/cosmos.group.v1.MsgExec": {
+        aminoType: string;
+        toAmino: (message: MsgExec) => import("./tx").MsgExecAmino;
+        fromAmino: (object: import("./tx").MsgExecAmino) => MsgExec;
+    };
+    "/cosmos.group.v1.MsgLeaveGroup": {
+        aminoType: string;
+        toAmino: (message: MsgLeaveGroup) => import("./tx").MsgLeaveGroupAmino;
+        fromAmino: (object: import("./tx").MsgLeaveGroupAmino) => MsgLeaveGroup;
+    };
+};

package/dist/cosmos/group/v1/tx.amino.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AminoConverter = void 0;
+//@ts-nocheck
+const tx_1 = require("./tx");
+exports.AminoConverter = {
+    "/cosmos.group.v1.MsgCreateGroup": {
+        aminoType: "cosmos-sdk/MsgCreateGroup",
+        toAmino: tx_1.MsgCreateGroup.toAmino,
+        fromAmino: tx_1.MsgCreateGroup.fromAmino
+    },
+    "/cosmos.group.v1.MsgUpdateGroupMembers": {
+        aminoType: "cosmos-sdk/MsgUpdateGroupMembers",
+        toAmino: tx_1.MsgUpdateGroupMembers.toAmino,
+        fromAmino: tx_1.MsgUpdateGroupMembers.fromAmino
+    },
+    "/cosmos.group.v1.MsgUpdateGroupAdmin": {
+        aminoType: "cosmos-sdk/MsgUpdateGroupAdmin",
+        toAmino: tx_1.MsgUpdateGroupAdmin.toAmino,
+        fromAmino: tx_1.MsgUpdateGroupAdmin.fromAmino
+    },
+    "/cosmos.group.v1.MsgUpdateGroupMetadata": {
+        aminoType: "cosmos-sdk/MsgUpdateGroupMetadata",
+        toAmino: tx_1.MsgUpdateGroupMetadata.toAmino,
+        fromAmino: tx_1.MsgUpdateGroupMetadata.fromAmino
+    },
+    "/cosmos.group.v1.MsgCreateGroupPolicy": {
+        aminoType: "cosmos-sdk/MsgCreateGroupPolicy",
+        toAmino: tx_1.MsgCreateGroupPolicy.toAmino,
+        fromAmino: tx_1.MsgCreateGroupPolicy.fromAmino
+    },
+    "/cosmos.group.v1.MsgCreateGroupWithPolicy": {
+        aminoType: "cosmos-sdk/MsgCreateGroupWithPolicy",
+        toAmino: tx_1.MsgCreateGroupWithPolicy.toAmino,
+        fromAmino: tx_1.MsgCreateGroupWithPolicy.fromAmino
+    },
+    "/cosmos.group.v1.MsgUpdateGroupPolicyAdmin": {
+        aminoType: "cosmos-sdk/MsgUpdateGroupPolicyAdmin",
+        toAmino: tx_1.MsgUpdateGroupPolicyAdmin.toAmino,
+        fromAmino: tx_1.MsgUpdateGroupPolicyAdmin.fromAmino
+    },
+    "/cosmos.group.v1.MsgUpdateGroupPolicyDecisionPolicy": {
+        aminoType: "cosmos-sdk/MsgUpdateGroupDecisionPolicy",
+        toAmino: tx_1.MsgUpdateGroupPolicyDecisionPolicy.toAmino,
+        fromAmino: tx_1.MsgUpdateGroupPolicyDecisionPolicy.fromAmino
+    },
+    "/cosmos.group.v1.MsgUpdateGroupPolicyMetadata": {
+        aminoType: "cosmos-sdk/MsgUpdateGroupPolicyMetadata",
+        toAmino: tx_1.MsgUpdateGroupPolicyMetadata.toAmino,
+        fromAmino: tx_1.MsgUpdateGroupPolicyMetadata.fromAmino
+    },
+    "/cosmos.group.v1.MsgSubmitProposal": {
+        aminoType: "cosmos-sdk/group/MsgSubmitProposal",
+        toAmino: tx_1.MsgSubmitProposal.toAmino,
+        fromAmino: tx_1.MsgSubmitProposal.fromAmino
+    },
+    "/cosmos.group.v1.MsgWithdrawProposal": {
+        aminoType: "cosmos-sdk/group/MsgWithdrawProposal",
+        toAmino: tx_1.MsgWithdrawProposal.toAmino,
+        fromAmino: tx_1.MsgWithdrawProposal.fromAmino
+    },
+    "/cosmos.group.v1.MsgVote": {
+        aminoType: "cosmos-sdk/group/MsgVote",
+        toAmino: tx_1.MsgVote.toAmino,
+        fromAmino: tx_1.MsgVote.fromAmino
+    },
+    "/cosmos.group.v1.MsgExec": {
+        aminoType: "cosmos-sdk/group/MsgExec",
+        toAmino: tx_1.MsgExec.toAmino,
+        fromAmino: tx_1.MsgExec.fromAmino
+    },
+    "/cosmos.group.v1.MsgLeaveGroup": {
+        aminoType: "cosmos-sdk/group/MsgLeaveGroup",
+        toAmino: tx_1.MsgLeaveGroup.toAmino,
+        fromAmino: tx_1.MsgLeaveGroup.fromAmino
+    }
+};