@block52/poker-vm-sdk 1.0.0

package/dist/cosmos.consensus.v1/rest.d.ts

@@ -0,0 +1,624 @@
+import { AxiosInstance, AxiosRequestConfig, AxiosResponse, ResponseType } from "axios";
+export type QueryParamsType = Record<string | number, any>;
+export type FlattenObject<TValue> = CollapseEntries<CreateObjectEntries<TValue, TValue>>;
+type Entry = {
+    key: string;
+    value: unknown;
+};
+type EmptyEntry<TValue> = {
+    key: '';
+    value: TValue;
+};
+type ExcludedTypes = Date | Set<unknown> | Map<unknown, unknown>;
+type ArrayEncoder = `[${bigint}]`;
+type EscapeArrayKey<TKey extends string> = TKey extends `${infer TKeyBefore}.${ArrayEncoder}${infer TKeyAfter}` ? EscapeArrayKey<`${TKeyBefore}${ArrayEncoder}${TKeyAfter}`> : TKey;
+type CollapseEntries<TEntry extends Entry> = {
+    [E in TEntry as EscapeArrayKey<E['key']>]: E['value'];
+};
+type CreateArrayEntry<TValue, TValueInitial> = OmitItself<TValue extends unknown[] ? {
+    [k: ArrayEncoder]: TValue[number];
+} : TValue, TValueInitial>;
+type OmitItself<TValue, TValueInitial> = TValue extends TValueInitial ? EmptyEntry<TValue> : OmitExcludedTypes<TValue, TValueInitial>;
+type OmitExcludedTypes<TValue, TValueInitial> = TValue extends ExcludedTypes ? EmptyEntry<TValue> : CreateObjectEntries<TValue, TValueInitial>;
+type CreateObjectEntries<TValue, TValueInitial> = TValue extends object ? {
+    [TKey in keyof TValue]-?: TKey extends string ? CreateArrayEntry<TValue[TKey], TValueInitial> extends infer TNestedValue ? TNestedValue extends Entry ? TNestedValue['key'] extends '' ? {
+        key: TKey;
+        value: TNestedValue['value'];
+    } : {
+        key: `${TKey}.${TNestedValue['key']}`;
+        value: TNestedValue['value'];
+    } | {
+        key: TKey;
+        value: TValue[TKey];
+    } : never : never : never;
+}[keyof TValue] : EmptyEntry<TValue>;
+export type ChangeProtoToJSPrimitives<T extends object> = {
+    [key in keyof T]: T[key] extends Uint8Array | Date ? string : T[key] extends object ? ChangeProtoToJSPrimitives<T[key]> : T[key];
+};
+export interface FullRequestParams extends Omit<AxiosRequestConfig, "data" | "params" | "url" | "responseType"> {
+    /** set parameter to `true` for call `securityWorker` for this request */
+    secure?: boolean;
+    /** request path */
+    path: string;
+    /** content type of request body */
+    type?: ContentType;
+    /** query params */
+    query?: QueryParamsType;
+    /** format of response (i.e. response.json() -> format: "json") */
+    format?: ResponseType;
+    /** request body */
+    body?: unknown;
+}
+export type RequestParams = Omit<FullRequestParams, "body" | "method" | "query" | "path">;
+export interface ApiConfig<SecurityDataType = unknown> extends Omit<AxiosRequestConfig, "data" | "cancelToken"> {
+    securityWorker?: (securityData: SecurityDataType | null) => Promise<AxiosRequestConfig | void> | AxiosRequestConfig | void;
+    secure?: boolean;
+    format?: ResponseType;
+}
+export declare enum ContentType {
+    Json = "application/json",
+    FormData = "multipart/form-data",
+    UrlEncoded = "application/x-www-form-urlencoded"
+}
+export declare class HttpClient<SecurityDataType = unknown> {
+    instance: AxiosInstance;
+    private securityData;
+    private securityWorker?;
+    private secure?;
+    private format?;
+    constructor({ securityWorker, secure, format, ...axiosConfig }?: ApiConfig<SecurityDataType>);
+    setSecurityData: (data: SecurityDataType | null) => void;
+    private mergeRequestParams;
+    private createFormData;
+    request: <T = any>({ secure, path, type, query, format, body, ...params }: FullRequestParams) => Promise<AxiosResponse<T>>;
+}
+/**
+ * @title cosmos.consensus.v1
+ */
+export declare class Api<SecurityDataType extends unknown> extends HttpClient<SecurityDataType> {
+    /**
+     * QueryParams
+     *
+     * @tags Query
+     * @name queryParams
+     * @request GET:/cosmos/consensus/v1/params
+     */
+    queryParams: (query?: Record<string, any>, params?: RequestParams) => Promise<AxiosResponse<{
+        params?: {
+            block?: {
+                max_bytes: {
+                    high: number;
+                    low: number;
+                    unsigned: boolean;
+                    add: (addend: import("long/umd/types").LongLike) => Long;
+                    and: (other: import("long/umd/types").LongLike) => Long;
+                    compare: (other: import("long/umd/types").LongLike) => number;
+                    comp: (other: import("long/umd/types").LongLike) => number;
+                    divide: (divisor: import("long/umd/types").LongLike) => Long;
+                    div: (divisor: import("long/umd/types").LongLike) => Long;
+                    equals: (other: import("long/umd/types").LongLike) => boolean;
+                    eq: (other: import("long/umd/types").LongLike) => boolean;
+                    get_high_bits: () => number;
+                    get_high_bits_unsigned: () => number;
+                    get_low_bits: () => number;
+                    get_low_bits_unsigned: () => number;
+                    get_num_bits_abs: () => number;
+                    greater_than: (other: import("long/umd/types").LongLike) => boolean;
+                    gt: (other: import("long/umd/types").LongLike) => boolean;
+                    greater_than_or_equal: (other: import("long/umd/types").LongLike) => boolean;
+                    gte: (other: import("long/umd/types").LongLike) => boolean;
+                    ge: (other: import("long/umd/types").LongLike) => boolean;
+                    is_even: () => boolean;
+                    is_negative: () => boolean;
+                    is_odd: () => boolean;
+                    is_positive: () => boolean;
+                    is_safe_integer: () => boolean;
+                    is_zero: () => boolean;
+                    eqz: () => boolean;
+                    less_than: (other: import("long/umd/types").LongLike) => boolean;
+                    lt: (other: import("long/umd/types").LongLike) => boolean;
+                    less_than_or_equal: (other: import("long/umd/types").LongLike) => boolean;
+                    lte: (other: import("long/umd/types").LongLike) => boolean;
+                    le: (other: import("long/umd/types").LongLike) => boolean;
+                    modulo: (other: import("long/umd/types").LongLike) => Long;
+                    mod: (other: import("long/umd/types").LongLike) => Long;
+                    rem: (other: import("long/umd/types").LongLike) => Long;
+                    multiply: (multiplier: import("long/umd/types").LongLike) => Long;
+                    mul: (multiplier: import("long/umd/types").LongLike) => Long;
+                    negate: () => Long;
+                    neg: () => Long;
+                    not: () => Long;
+                    count_leading_zeros: () => number;
+                    clz: () => number;
+                    count_trailing_zeros: () => number;
+                    ctz: () => number;
+                    not_equals: (other: import("long/umd/types").LongLike) => boolean;
+                    neq: (other: import("long/umd/types").LongLike) => boolean;
+                    ne: (other: import("long/umd/types").LongLike) => boolean;
+                    or: (other: import("long/umd/types").LongLike) => Long;
+                    shift_left: (numBits: number | Long) => Long;
+                    shl: (numBits: number | Long) => Long;
+                    shift_right: (numBits: number | Long) => Long;
+                    shr: (numBits: number | Long) => Long;
+                    shift_right_unsigned: (numBits: number | Long) => Long;
+                    shru: (numBits: number | Long) => Long;
+                    shr_u: (numBits: number | Long) => Long;
+                    rotate_left: (numBits: number | Long) => Long;
+                    rotl: (numBits: number | Long) => Long;
+                    rotate_right: (numBits: number | Long) => Long;
+                    rotr: (numBits: number | Long) => Long;
+                    subtract: (subtrahend: import("long/umd/types").LongLike) => Long;
+                    sub: (subtrahend: import("long/umd/types").LongLike) => Long;
+                    to_big_int: () => bigint;
+                    to_int: () => number;
+                    to_number: () => number;
+                    to_bytes: (le?: boolean) => number[];
+                    to_bytes_le: () => number[];
+                    to_bytes_be: () => number[];
+                    to_signed: () => Long;
+                    to_string: (radix?: number) => string;
+                    to_unsigned: () => Long;
+                    xor: (other: import("long/umd/types").LongLike) => Long;
+                };
+                max_gas: {
+                    high: number;
+                    low: number;
+                    unsigned: boolean;
+                    add: (addend: import("long/umd/types").LongLike) => Long;
+                    and: (other: import("long/umd/types").LongLike) => Long;
+                    compare: (other: import("long/umd/types").LongLike) => number;
+                    comp: (other: import("long/umd/types").LongLike) => number;
+                    divide: (divisor: import("long/umd/types").LongLike) => Long;
+                    div: (divisor: import("long/umd/types").LongLike) => Long;
+                    equals: (other: import("long/umd/types").LongLike) => boolean;
+                    eq: (other: import("long/umd/types").LongLike) => boolean;
+                    get_high_bits: () => number;
+                    get_high_bits_unsigned: () => number;
+                    get_low_bits: () => number;
+                    get_low_bits_unsigned: () => number;
+                    get_num_bits_abs: () => number;
+                    greater_than: (other: import("long/umd/types").LongLike) => boolean;
+                    gt: (other: import("long/umd/types").LongLike) => boolean;
+                    greater_than_or_equal: (other: import("long/umd/types").LongLike) => boolean;
+                    gte: (other: import("long/umd/types").LongLike) => boolean;
+                    ge: (other: import("long/umd/types").LongLike) => boolean;
+                    is_even: () => boolean;
+                    is_negative: () => boolean;
+                    is_odd: () => boolean;
+                    is_positive: () => boolean;
+                    is_safe_integer: () => boolean;
+                    is_zero: () => boolean;
+                    eqz: () => boolean;
+                    less_than: (other: import("long/umd/types").LongLike) => boolean;
+                    lt: (other: import("long/umd/types").LongLike) => boolean;
+                    less_than_or_equal: (other: import("long/umd/types").LongLike) => boolean;
+                    lte: (other: import("long/umd/types").LongLike) => boolean;
+                    le: (other: import("long/umd/types").LongLike) => boolean;
+                    modulo: (other: import("long/umd/types").LongLike) => Long;
+                    mod: (other: import("long/umd/types").LongLike) => Long;
+                    rem: (other: import("long/umd/types").LongLike) => Long;
+                    multiply: (multiplier: import("long/umd/types").LongLike) => Long;
+                    mul: (multiplier: import("long/umd/types").LongLike) => Long;
+                    negate: () => Long;
+                    neg: () => Long;
+                    not: () => Long;
+                    count_leading_zeros: () => number;
+                    clz: () => number;
+                    count_trailing_zeros: () => number;
+                    ctz: () => number;
+                    not_equals: (other: import("long/umd/types").LongLike) => boolean;
+                    neq: (other: import("long/umd/types").LongLike) => boolean;
+                    ne: (other: import("long/umd/types").LongLike) => boolean;
+                    or: (other: import("long/umd/types").LongLike) => Long;
+                    shift_left: (numBits: number | Long) => Long;
+                    shl: (numBits: number | Long) => Long;
+                    shift_right: (numBits: number | Long) => Long;
+                    shr: (numBits: number | Long) => Long;
+                    shift_right_unsigned: (numBits: number | Long) => Long;
+                    shru: (numBits: number | Long) => Long;
+                    shr_u: (numBits: number | Long) => Long;
+                    rotate_left: (numBits: number | Long) => Long;
+                    rotl: (numBits: number | Long) => Long;
+                    rotate_right: (numBits: number | Long) => Long;
+                    rotr: (numBits: number | Long) => Long;
+                    subtract: (subtrahend: import("long/umd/types").LongLike) => Long;
+                    sub: (subtrahend: import("long/umd/types").LongLike) => Long;
+                    to_big_int: () => bigint;
+                    to_int: () => number;
+                    to_number: () => number;
+                    to_bytes: (le?: boolean) => number[];
+                    to_bytes_le: () => number[];
+                    to_bytes_be: () => number[];
+                    to_signed: () => Long;
+                    to_string: (radix?: number) => string;
+                    to_unsigned: () => Long;
+                    xor: (other: import("long/umd/types").LongLike) => Long;
+                };
+            } | undefined;
+            evidence?: {
+                max_age_num_blocks: {
+                    high: number;
+                    low: number;
+                    unsigned: boolean;
+                    add: (addend: import("long/umd/types").LongLike) => Long;
+                    and: (other: import("long/umd/types").LongLike) => Long;
+                    compare: (other: import("long/umd/types").LongLike) => number;
+                    comp: (other: import("long/umd/types").LongLike) => number;
+                    divide: (divisor: import("long/umd/types").LongLike) => Long;
+                    div: (divisor: import("long/umd/types").LongLike) => Long;
+                    equals: (other: import("long/umd/types").LongLike) => boolean;
+                    eq: (other: import("long/umd/types").LongLike) => boolean;
+                    get_high_bits: () => number;
+                    get_high_bits_unsigned: () => number;
+                    get_low_bits: () => number;
+                    get_low_bits_unsigned: () => number;
+                    get_num_bits_abs: () => number;
+                    greater_than: (other: import("long/umd/types").LongLike) => boolean;
+                    gt: (other: import("long/umd/types").LongLike) => boolean;
+                    greater_than_or_equal: (other: import("long/umd/types").LongLike) => boolean;
+                    gte: (other: import("long/umd/types").LongLike) => boolean;
+                    ge: (other: import("long/umd/types").LongLike) => boolean;
+                    is_even: () => boolean;
+                    is_negative: () => boolean;
+                    is_odd: () => boolean;
+                    is_positive: () => boolean;
+                    is_safe_integer: () => boolean;
+                    is_zero: () => boolean;
+                    eqz: () => boolean;
+                    less_than: (other: import("long/umd/types").LongLike) => boolean;
+                    lt: (other: import("long/umd/types").LongLike) => boolean;
+                    less_than_or_equal: (other: import("long/umd/types").LongLike) => boolean;
+                    lte: (other: import("long/umd/types").LongLike) => boolean;
+                    le: (other: import("long/umd/types").LongLike) => boolean;
+                    modulo: (other: import("long/umd/types").LongLike) => Long;
+                    mod: (other: import("long/umd/types").LongLike) => Long;
+                    rem: (other: import("long/umd/types").LongLike) => Long;
+                    multiply: (multiplier: import("long/umd/types").LongLike) => Long;
+                    mul: (multiplier: import("long/umd/types").LongLike) => Long;
+                    negate: () => Long;
+                    neg: () => Long;
+                    not: () => Long;
+                    count_leading_zeros: () => number;
+                    clz: () => number;
+                    count_trailing_zeros: () => number;
+                    ctz: () => number;
+                    not_equals: (other: import("long/umd/types").LongLike) => boolean;
+                    neq: (other: import("long/umd/types").LongLike) => boolean;
+                    ne: (other: import("long/umd/types").LongLike) => boolean;
+                    or: (other: import("long/umd/types").LongLike) => Long;
+                    shift_left: (numBits: number | Long) => Long;
+                    shl: (numBits: number | Long) => Long;
+                    shift_right: (numBits: number | Long) => Long;
+                    shr: (numBits: number | Long) => Long;
+                    shift_right_unsigned: (numBits: number | Long) => Long;
+                    shru: (numBits: number | Long) => Long;
+                    shr_u: (numBits: number | Long) => Long;
+                    rotate_left: (numBits: number | Long) => Long;
+                    rotl: (numBits: number | Long) => Long;
+                    rotate_right: (numBits: number | Long) => Long;
+                    rotr: (numBits: number | Long) => Long;
+                    subtract: (subtrahend: import("long/umd/types").LongLike) => Long;
+                    sub: (subtrahend: import("long/umd/types").LongLike) => Long;
+                    to_big_int: () => bigint;
+                    to_int: () => number;
+                    to_number: () => number;
+                    to_bytes: (le?: boolean) => number[];
+                    to_bytes_le: () => number[];
+                    to_bytes_be: () => number[];
+                    to_signed: () => Long;
+                    to_string: (radix?: number) => string;
+                    to_unsigned: () => Long;
+                    xor: (other: import("long/umd/types").LongLike) => Long;
+                };
+                max_age_duration?: {
+                    seconds: {
+                        high: number;
+                        low: number;
+                        unsigned: boolean;
+                        add: (addend: import("long/umd/types").LongLike) => Long;
+                        and: (other: import("long/umd/types").LongLike) => Long;
+                        compare: (other: import("long/umd/types").LongLike) => number;
+                        comp: (other: import("long/umd/types").LongLike) => number;
+                        divide: (divisor: import("long/umd/types").LongLike) => Long;
+                        div: (divisor: import("long/umd/types").LongLike) => Long;
+                        equals: (other: import("long/umd/types").LongLike) => boolean;
+                        eq: (other: import("long/umd/types").LongLike) => boolean;
+                        get_high_bits: () => number;
+                        get_high_bits_unsigned: () => number;
+                        get_low_bits: () => number;
+                        get_low_bits_unsigned: () => number;
+                        get_num_bits_abs: () => number;
+                        greater_than: (other: import("long/umd/types").LongLike) => boolean;
+                        gt: (other: import("long/umd/types").LongLike) => boolean;
+                        greater_than_or_equal: (other: import("long/umd/types").LongLike) => boolean;
+                        gte: (other: import("long/umd/types").LongLike) => boolean;
+                        ge: (other: import("long/umd/types").LongLike) => boolean;
+                        is_even: () => boolean;
+                        is_negative: () => boolean;
+                        is_odd: () => boolean;
+                        is_positive: () => boolean;
+                        is_safe_integer: () => boolean;
+                        is_zero: () => boolean;
+                        eqz: () => boolean;
+                        less_than: (other: import("long/umd/types").LongLike) => boolean;
+                        lt: (other: import("long/umd/types").LongLike) => boolean;
+                        less_than_or_equal: (other: import("long/umd/types").LongLike) => boolean;
+                        lte: (other: import("long/umd/types").LongLike) => boolean;
+                        le: (other: import("long/umd/types").LongLike) => boolean;
+                        modulo: (other: import("long/umd/types").LongLike) => Long;
+                        mod: (other: import("long/umd/types").LongLike) => Long;
+                        rem: (other: import("long/umd/types").LongLike) => Long;
+                        multiply: (multiplier: import("long/umd/types").LongLike) => Long;
+                        mul: (multiplier: import("long/umd/types").LongLike) => Long;
+                        negate: () => Long;
+                        neg: () => Long;
+                        not: () => Long;
+                        count_leading_zeros: () => number;
+                        clz: () => number;
+                        count_trailing_zeros: () => number;
+                        ctz: () => number;
+                        not_equals: (other: import("long/umd/types").LongLike) => boolean;
+                        neq: (other: import("long/umd/types").LongLike) => boolean;
+                        ne: (other: import("long/umd/types").LongLike) => boolean;
+                        or: (other: import("long/umd/types").LongLike) => Long;
+                        shift_left: (numBits: number | Long) => Long;
+                        shl: (numBits: number | Long) => Long;
+                        shift_right: (numBits: number | Long) => Long;
+                        shr: (numBits: number | Long) => Long;
+                        shift_right_unsigned: (numBits: number | Long) => Long;
+                        shru: (numBits: number | Long) => Long;
+                        shr_u: (numBits: number | Long) => Long;
+                        rotate_left: (numBits: number | Long) => Long;
+                        rotl: (numBits: number | Long) => Long;
+                        rotate_right: (numBits: number | Long) => Long;
+                        rotr: (numBits: number | Long) => Long;
+                        subtract: (subtrahend: import("long/umd/types").LongLike) => Long;
+                        sub: (subtrahend: import("long/umd/types").LongLike) => Long;
+                        to_big_int: () => bigint;
+                        to_int: () => number;
+                        to_number: () => number;
+                        to_bytes: (le?: boolean) => number[];
+                        to_bytes_le: () => number[];
+                        to_bytes_be: () => number[];
+                        to_signed: () => Long;
+                        to_string: (radix?: number) => string;
+                        to_unsigned: () => Long;
+                        xor: (other: import("long/umd/types").LongLike) => Long;
+                    };
+                    nanos: number;
+                } | undefined;
+                max_bytes: {
+                    high: number;
+                    low: number;
+                    unsigned: boolean;
+                    add: (addend: import("long/umd/types").LongLike) => Long;
+                    and: (other: import("long/umd/types").LongLike) => Long;
+                    compare: (other: import("long/umd/types").LongLike) => number;
+                    comp: (other: import("long/umd/types").LongLike) => number;
+                    divide: (divisor: import("long/umd/types").LongLike) => Long;
+                    div: (divisor: import("long/umd/types").LongLike) => Long;
+                    equals: (other: import("long/umd/types").LongLike) => boolean;
+                    eq: (other: import("long/umd/types").LongLike) => boolean;
+                    get_high_bits: () => number;
+                    get_high_bits_unsigned: () => number;
+                    get_low_bits: () => number;
+                    get_low_bits_unsigned: () => number;
+                    get_num_bits_abs: () => number;
+                    greater_than: (other: import("long/umd/types").LongLike) => boolean;
+                    gt: (other: import("long/umd/types").LongLike) => boolean;
+                    greater_than_or_equal: (other: import("long/umd/types").LongLike) => boolean;
+                    gte: (other: import("long/umd/types").LongLike) => boolean;
+                    ge: (other: import("long/umd/types").LongLike) => boolean;
+                    is_even: () => boolean;
+                    is_negative: () => boolean;
+                    is_odd: () => boolean;
+                    is_positive: () => boolean;
+                    is_safe_integer: () => boolean;
+                    is_zero: () => boolean;
+                    eqz: () => boolean;
+                    less_than: (other: import("long/umd/types").LongLike) => boolean;
+                    lt: (other: import("long/umd/types").LongLike) => boolean;
+                    less_than_or_equal: (other: import("long/umd/types").LongLike) => boolean;
+                    lte: (other: import("long/umd/types").LongLike) => boolean;
+                    le: (other: import("long/umd/types").LongLike) => boolean;
+                    modulo: (other: import("long/umd/types").LongLike) => Long;
+                    mod: (other: import("long/umd/types").LongLike) => Long;
+                    rem: (other: import("long/umd/types").LongLike) => Long;
+                    multiply: (multiplier: import("long/umd/types").LongLike) => Long;
+                    mul: (multiplier: import("long/umd/types").LongLike) => Long;
+                    negate: () => Long;
+                    neg: () => Long;
+                    not: () => Long;
+                    count_leading_zeros: () => number;
+                    clz: () => number;
+                    count_trailing_zeros: () => number;
+                    ctz: () => number;
+                    not_equals: (other: import("long/umd/types").LongLike) => boolean;
+                    neq: (other: import("long/umd/types").LongLike) => boolean;
+                    ne: (other: import("long/umd/types").LongLike) => boolean;
+                    or: (other: import("long/umd/types").LongLike) => Long;
+                    shift_left: (numBits: number | Long) => Long;
+                    shl: (numBits: number | Long) => Long;
+                    shift_right: (numBits: number | Long) => Long;
+                    shr: (numBits: number | Long) => Long;
+                    shift_right_unsigned: (numBits: number | Long) => Long;
+                    shru: (numBits: number | Long) => Long;
+                    shr_u: (numBits: number | Long) => Long;
+                    rotate_left: (numBits: number | Long) => Long;
+                    rotl: (numBits: number | Long) => Long;
+                    rotate_right: (numBits: number | Long) => Long;
+                    rotr: (numBits: number | Long) => Long;
+                    subtract: (subtrahend: import("long/umd/types").LongLike) => Long;
+                    sub: (subtrahend: import("long/umd/types").LongLike) => Long;
+                    to_big_int: () => bigint;
+                    to_int: () => number;
+                    to_number: () => number;
+                    to_bytes: (le?: boolean) => number[];
+                    to_bytes_le: () => number[];
+                    to_bytes_be: () => number[];
+                    to_signed: () => Long;
+                    to_string: (radix?: number) => string;
+                    to_unsigned: () => Long;
+                    xor: (other: import("long/umd/types").LongLike) => Long;
+                };
+            } | undefined;
+            validator?: {
+                pub_key_types: string[];
+            } | undefined;
+            version?: {
+                app: {
+                    high: number;
+                    low: number;
+                    unsigned: boolean;
+                    add: (addend: import("long/umd/types").LongLike) => Long;
+                    and: (other: import("long/umd/types").LongLike) => Long;
+                    compare: (other: import("long/umd/types").LongLike) => number;
+                    comp: (other: import("long/umd/types").LongLike) => number;
+                    divide: (divisor: import("long/umd/types").LongLike) => Long;
+                    div: (divisor: import("long/umd/types").LongLike) => Long;
+                    equals: (other: import("long/umd/types").LongLike) => boolean;
+                    eq: (other: import("long/umd/types").LongLike) => boolean;
+                    get_high_bits: () => number;
+                    get_high_bits_unsigned: () => number;
+                    get_low_bits: () => number;
+                    get_low_bits_unsigned: () => number;
+                    get_num_bits_abs: () => number;
+                    greater_than: (other: import("long/umd/types").LongLike) => boolean;
+                    gt: (other: import("long/umd/types").LongLike) => boolean;
+                    greater_than_or_equal: (other: import("long/umd/types").LongLike) => boolean;
+                    gte: (other: import("long/umd/types").LongLike) => boolean;
+                    ge: (other: import("long/umd/types").LongLike) => boolean;
+                    is_even: () => boolean;
+                    is_negative: () => boolean;
+                    is_odd: () => boolean;
+                    is_positive: () => boolean;
+                    is_safe_integer: () => boolean;
+                    is_zero: () => boolean;
+                    eqz: () => boolean;
+                    less_than: (other: import("long/umd/types").LongLike) => boolean;
+                    lt: (other: import("long/umd/types").LongLike) => boolean;
+                    less_than_or_equal: (other: import("long/umd/types").LongLike) => boolean;
+                    lte: (other: import("long/umd/types").LongLike) => boolean;
+                    le: (other: import("long/umd/types").LongLike) => boolean;
+                    modulo: (other: import("long/umd/types").LongLike) => Long;
+                    mod: (other: import("long/umd/types").LongLike) => Long;
+                    rem: (other: import("long/umd/types").LongLike) => Long;
+                    multiply: (multiplier: import("long/umd/types").LongLike) => Long;
+                    mul: (multiplier: import("long/umd/types").LongLike) => Long;
+                    negate: () => Long;
+                    neg: () => Long;
+                    not: () => Long;
+                    count_leading_zeros: () => number;
+                    clz: () => number;
+                    count_trailing_zeros: () => number;
+                    ctz: () => number;
+                    not_equals: (other: import("long/umd/types").LongLike) => boolean;
+                    neq: (other: import("long/umd/types").LongLike) => boolean;
+                    ne: (other: import("long/umd/types").LongLike) => boolean;
+                    or: (other: import("long/umd/types").LongLike) => Long;
+                    shift_left: (numBits: number | Long) => Long;
+                    shl: (numBits: number | Long) => Long;
+                    shift_right: (numBits: number | Long) => Long;
+                    shr: (numBits: number | Long) => Long;
+                    shift_right_unsigned: (numBits: number | Long) => Long;
+                    shru: (numBits: number | Long) => Long;
+                    shr_u: (numBits: number | Long) => Long;
+                    rotate_left: (numBits: number | Long) => Long;
+                    rotl: (numBits: number | Long) => Long;
+                    rotate_right: (numBits: number | Long) => Long;
+                    rotr: (numBits: number | Long) => Long;
+                    subtract: (subtrahend: import("long/umd/types").LongLike) => Long;
+                    sub: (subtrahend: import("long/umd/types").LongLike) => Long;
+                    to_big_int: () => bigint;
+                    to_int: () => number;
+                    to_number: () => number;
+                    to_bytes: (le?: boolean) => number[];
+                    to_bytes_le: () => number[];
+                    to_bytes_be: () => number[];
+                    to_signed: () => Long;
+                    to_string: (radix?: number) => string;
+                    to_unsigned: () => Long;
+                    xor: (other: import("long/umd/types").LongLike) => Long;
+                };
+            } | undefined;
+            abci?: {
+                vote_extensions_enable_height: {
+                    high: number;
+                    low: number;
+                    unsigned: boolean;
+                    add: (addend: import("long/umd/types").LongLike) => Long;
+                    and: (other: import("long/umd/types").LongLike) => Long;
+                    compare: (other: import("long/umd/types").LongLike) => number;
+                    comp: (other: import("long/umd/types").LongLike) => number;
+                    divide: (divisor: import("long/umd/types").LongLike) => Long;
+                    div: (divisor: import("long/umd/types").LongLike) => Long;
+                    equals: (other: import("long/umd/types").LongLike) => boolean;
+                    eq: (other: import("long/umd/types").LongLike) => boolean;
+                    get_high_bits: () => number;
+                    get_high_bits_unsigned: () => number;
+                    get_low_bits: () => number;
+                    get_low_bits_unsigned: () => number;
+                    get_num_bits_abs: () => number;
+                    greater_than: (other: import("long/umd/types").LongLike) => boolean;
+                    gt: (other: import("long/umd/types").LongLike) => boolean;
+                    greater_than_or_equal: (other: import("long/umd/types").LongLike) => boolean;
+                    gte: (other: import("long/umd/types").LongLike) => boolean;
+                    ge: (other: import("long/umd/types").LongLike) => boolean;
+                    is_even: () => boolean;
+                    is_negative: () => boolean;
+                    is_odd: () => boolean;
+                    is_positive: () => boolean;
+                    is_safe_integer: () => boolean;
+                    is_zero: () => boolean;
+                    eqz: () => boolean;
+                    less_than: (other: import("long/umd/types").LongLike) => boolean;
+                    lt: (other: import("long/umd/types").LongLike) => boolean;
+                    less_than_or_equal: (other: import("long/umd/types").LongLike) => boolean;
+                    lte: (other: import("long/umd/types").LongLike) => boolean;
+                    le: (other: import("long/umd/types").LongLike) => boolean;
+                    modulo: (other: import("long/umd/types").LongLike) => Long;
+                    mod: (other: import("long/umd/types").LongLike) => Long;
+                    rem: (other: import("long/umd/types").LongLike) => Long;
+                    multiply: (multiplier: import("long/umd/types").LongLike) => Long;
+                    mul: (multiplier: import("long/umd/types").LongLike) => Long;
+                    negate: () => Long;
+                    neg: () => Long;
+                    not: () => Long;
+                    count_leading_zeros: () => number;
+                    clz: () => number;
+                    count_trailing_zeros: () => number;
+                    ctz: () => number;
+                    not_equals: (other: import("long/umd/types").LongLike) => boolean;
+                    neq: (other: import("long/umd/types").LongLike) => boolean;
+                    ne: (other: import("long/umd/types").LongLike) => boolean;
+                    or: (other: import("long/umd/types").LongLike) => Long;
+                    shift_left: (numBits: number | Long) => Long;
+                    shl: (numBits: number | Long) => Long;
+                    shift_right: (numBits: number | Long) => Long;
+                    shr: (numBits: number | Long) => Long;
+                    shift_right_unsigned: (numBits: number | Long) => Long;
+                    shru: (numBits: number | Long) => Long;
+                    shr_u: (numBits: number | Long) => Long;
+                    rotate_left: (numBits: number | Long) => Long;
+                    rotl: (numBits: number | Long) => Long;
+                    rotate_right: (numBits: number | Long) => Long;
+                    rotr: (numBits: number | Long) => Long;
+                    subtract: (subtrahend: import("long/umd/types").LongLike) => Long;
+                    sub: (subtrahend: import("long/umd/types").LongLike) => Long;
+                    to_big_int: () => bigint;
+                    to_int: () => number;
+                    to_number: () => number;
+                    to_bytes: (le?: boolean) => number[];
+                    to_bytes_le: () => number[];
+                    to_bytes_be: () => number[];
+                    to_signed: () => Long;
+                    to_string: (radix?: number) => string;
+                    to_unsigned: () => Long;
+                    xor: (other: import("long/umd/types").LongLike) => Long;
+                };
+            } | undefined;
+        } | undefined;
+    }, any, {}>>;
+}
+export {};
+//# sourceMappingURL=rest.d.ts.map

package/dist/cosmos.consensus.v1/rest.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rest.d.ts","sourceRoot":"","sources":["../../src/cosmos.consensus.v1/rest.ts"],"names":[],"mappings":"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"}

package/dist/cosmos.consensus.v1/types/amino/amino.d.ts

@@ -0,0 +1,2 @@
+export declare const protobufPackage = "amino";
+//# sourceMappingURL=amino.d.ts.map

package/dist/cosmos.consensus.v1/types/amino/amino.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"amino.d.ts","sourceRoot":"","sources":["../../../../src/cosmos.consensus.v1/types/amino/amino.ts"],"names":[],"mappings":"AAQA,eAAO,MAAM,eAAe,UAAU,CAAC"}