@iconlake/client 1.3.1 → 1.5.0

package/types/iconlake.lake/module.d.ts

@@ -0,0 +1,55 @@
+import { StdFee } from "@cosmjs/launchpad";
+import { DeliverTxResponse } from "@cosmjs/stargate";
+import { EncodeObject, GeneratedType, OfflineSigner, Registry } from "@cosmjs/proto-signing";
+import { IgniteClient } from "../client";
+import { Api } from "./rest";
+import { MsgCreateAllowedSender } from "./types/iconlake/lake/tx";
+import { MsgDeleteAllowedSender } from "./types/iconlake/lake/tx";
+export { MsgCreateAllowedSender, MsgDeleteAllowedSender };
+type sendMsgCreateAllowedSenderParams = {
+    value: MsgCreateAllowedSender;
+    fee?: StdFee;
+    memo?: string;
+};
+type sendMsgDeleteAllowedSenderParams = {
+    value: MsgDeleteAllowedSender;
+    fee?: StdFee;
+    memo?: string;
+};
+type msgCreateAllowedSenderParams = {
+    value: MsgCreateAllowedSender;
+};
+type msgDeleteAllowedSenderParams = {
+    value: MsgDeleteAllowedSender;
+};
+export declare const registry: Registry;
+interface TxClientOptions {
+    addr: string;
+    prefix: string;
+    signer?: OfflineSigner;
+}
+export declare const txClient: ({ signer, prefix, addr }?: TxClientOptions) => {
+    sendMsgCreateAllowedSender({ value, fee, memo }: sendMsgCreateAllowedSenderParams): Promise<DeliverTxResponse>;
+    sendMsgDeleteAllowedSender({ value, fee, memo }: sendMsgDeleteAllowedSenderParams): Promise<DeliverTxResponse>;
+    msgCreateAllowedSender({ value }: msgCreateAllowedSenderParams): EncodeObject;
+    msgDeleteAllowedSender({ value }: msgDeleteAllowedSenderParams): EncodeObject;
+};
+interface QueryClientOptions {
+    addr: string;
+}
+export declare const queryClient: ({ addr: addr }?: QueryClientOptions) => Api<unknown>;
+declare class SDKModule {
+    query: ReturnType<typeof queryClient>;
+    tx: ReturnType<typeof txClient>;
+    structure: Record<string, unknown>;
+    registry: Array<[string, GeneratedType]>;
+    constructor(client: IgniteClient);
+    updateTX(client: IgniteClient): void;
+}
+declare const Module: (test: IgniteClient) => {
+    module: {
+        IconlakeLake: SDKModule;
+    };
+    registry: [string, GeneratedType][];
+};
+export default Module;

package/types/iconlake.lake/registry.d.ts

@@ -0,0 +1,3 @@
+import { GeneratedType } from "@cosmjs/proto-signing";
+declare const msgTypes: Array<[string, GeneratedType]>;
+export { msgTypes };

package/types/iconlake.lake/rest.d.ts

@@ -0,0 +1,183 @@
+export interface LakeAllowedSender {
+    address?: string;
+}
+export type LakeMsgCreateAllowedSenderResponse = object;
+export type LakeMsgDeleteAllowedSenderResponse = object;
+/**
+ * Params defines the parameters for the module.
+ */
+export type LakeParams = object;
+export interface LakeQueryAllAllowedSenderResponse {
+    allowedSender?: LakeAllowedSender[];
+    /**
+     * PageResponse is to be embedded in gRPC response messages where the
+     * corresponding request message has used PageRequest.
+     *
+     *  message SomeResponse {
+     *          repeated Bar results = 1;
+     *          PageResponse page = 2;
+     *  }
+     */
+    pagination?: V1Beta1PageResponse;
+}
+export interface LakeQueryGetAllowedSenderResponse {
+    allowedSender?: LakeAllowedSender;
+}
+/**
+ * QueryParamsResponse is response type for the Query/Params RPC method.
+ */
+export interface LakeQueryParamsResponse {
+    /** params holds all the parameters of this module. */
+    params?: LakeParams;
+}
+export interface ProtobufAny {
+    "@type"?: string;
+}
+export interface RpcStatus {
+    /** @format int32 */
+    code?: number;
+    message?: string;
+    details?: ProtobufAny[];
+}
+/**
+* message SomeRequest {
+         Foo some_parameter = 1;
+         PageRequest pagination = 2;
+ }
+*/
+export interface V1Beta1PageRequest {
+    /**
+     * key is a value returned in PageResponse.next_key to begin
+     * querying the next page most efficiently. Only one of offset or key
+     * should be set.
+     * @format byte
+     */
+    key?: string;
+    /**
+     * offset is a numeric offset that can be used when key is unavailable.
+     * It is less efficient than using key. Only one of offset or key should
+     * be set.
+     * @format uint64
+     */
+    offset?: string;
+    /**
+     * limit is the total number of results to be returned in the result page.
+     * If left empty it will default to a value to be set by each app.
+     * @format uint64
+     */
+    limit?: string;
+    /**
+     * count_total is set to true  to indicate that the result set should include
+     * a count of the total number of items available for pagination in UIs.
+     * count_total is only respected when offset is used. It is ignored when key
+     * is set.
+     */
+    count_total?: boolean;
+    /**
+     * reverse is set to true if results are to be returned in the descending order.
+     *
+     * Since: cosmos-sdk 0.43
+     */
+    reverse?: boolean;
+}
+/**
+* PageResponse is to be embedded in gRPC response messages where the
+corresponding request message has used PageRequest.
+
+ message SomeResponse {
+         repeated Bar results = 1;
+         PageResponse page = 2;
+ }
+*/
+export interface V1Beta1PageResponse {
+    /**
+     * next_key is the key to be passed to PageRequest.key to
+     * query the next page most efficiently. It will be empty if
+     * there are no more results.
+     * @format byte
+     */
+    next_key?: string;
+    /**
+     * total is total number of results available if PageRequest.count_total
+     * was set, its value is undefined otherwise
+     * @format uint64
+     */
+    total?: string;
+}
+import { AxiosInstance, AxiosRequestConfig, AxiosResponse, ResponseType } from "axios";
+export type QueryParamsType = Record<string | number, any>;
+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, _E = any>({ secure, path, type, query, format, body, ...params }: FullRequestParams) => Promise<AxiosResponse<T>>;
+}
+/**
+ * @title iconlake/lake/allowed_sender.proto
+ * @version version not set
+ */
+export declare class Api<SecurityDataType extends unknown> extends HttpClient<SecurityDataType> {
+    /**
+     * No description
+     *
+     * @tags Query
+     * @name QueryAllowedSenderAll
+     * @request GET:/iconlake/lake/allowed_sender
+     */
+    queryAllowedSenderAll: (query?: {
+        "pagination.key"?: string;
+        "pagination.offset"?: string;
+        "pagination.limit"?: string;
+        "pagination.count_total"?: boolean;
+        "pagination.reverse"?: boolean;
+    }, params?: RequestParams) => Promise<AxiosResponse<LakeQueryAllAllowedSenderResponse>>;
+    /**
+     * No description
+     *
+     * @tags Query
+     * @name QueryAllowedSender
+     * @summary Queries a list of AllowedSender items.
+     * @request GET:/iconlake/lake/allowed_sender/{address}
+     */
+    queryAllowedSender: (address: string, params?: RequestParams) => Promise<AxiosResponse<LakeQueryGetAllowedSenderResponse>>;
+    /**
+     * No description
+     *
+     * @tags Query
+     * @name QueryParams
+     * @summary Parameters queries the parameters of the module.
+     * @request GET:/iconlake/lake/params
+     */
+    queryParams: (params?: RequestParams) => Promise<AxiosResponse<LakeQueryParamsResponse>>;
+}

package/types/iconlake.lake/types/cosmos/base/query/v1beta1/pagination.d.ts

@@ -0,0 +1,108 @@
+import _m0 from "protobufjs/minimal";
+export declare const protobufPackage = "cosmos.base.query.v1beta1";
+/**
+ * PageRequest is to be embedded in gRPC request messages for efficient
+ * pagination. Ex:
+ *
+ *  message SomeRequest {
+ *          Foo some_parameter = 1;
+ *          PageRequest pagination = 2;
+ *  }
+ */
+export interface PageRequest {
+    /**
+     * key is a value returned in PageResponse.next_key to begin
+     * querying the next page most efficiently. Only one of offset or key
+     * should be set.
+     */
+    key: Uint8Array;
+    /**
+     * offset is a numeric offset that can be used when key is unavailable.
+     * It is less efficient than using key. Only one of offset or key should
+     * be set.
+     */
+    offset: number;
+    /**
+     * limit is the total number of results to be returned in the result page.
+     * If left empty it will default to a value to be set by each app.
+     */
+    limit: number;
+    /**
+     * count_total is set to true  to indicate that the result set should include
+     * a count of the total number of items available for pagination in UIs.
+     * count_total is only respected when offset is used. It is ignored when key
+     * is set.
+     */
+    countTotal: boolean;
+    /**
+     * reverse is set to true if results are to be returned in the descending order.
+     *
+     * Since: cosmos-sdk 0.43
+     */
+    reverse: boolean;
+}
+/**
+ * PageResponse is to be embedded in gRPC response messages where the
+ * corresponding request message has used PageRequest.
+ *
+ *  message SomeResponse {
+ *          repeated Bar results = 1;
+ *          PageResponse page = 2;
+ *  }
+ */
+export interface PageResponse {
+    /**
+     * next_key is the key to be passed to PageRequest.key to
+     * query the next page most efficiently. It will be empty if
+     * there are no more results.
+     */
+    nextKey: Uint8Array;
+    /**
+     * total is total number of results available if PageRequest.count_total
+     * was set, its value is undefined otherwise
+     */
+    total: number;
+}
+export declare const PageRequest: {
+    encode(message: PageRequest, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): PageRequest;
+    fromJSON(object: any): PageRequest;
+    toJSON(message: PageRequest): unknown;
+    fromPartial<I extends {
+        key?: Uint8Array;
+        offset?: number;
+        limit?: number;
+        countTotal?: boolean;
+        reverse?: boolean;
+    } & {
+        key?: Uint8Array;
+        offset?: number;
+        limit?: number;
+        countTotal?: boolean;
+        reverse?: boolean;
+    } & { [K in Exclude<keyof I, keyof PageRequest>]: never; }>(object: I): PageRequest;
+};
+export declare const PageResponse: {
+    encode(message: PageResponse, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): PageResponse;
+    fromJSON(object: any): PageResponse;
+    toJSON(message: PageResponse): unknown;
+    fromPartial<I extends {
+        nextKey?: Uint8Array;
+        total?: number;
+    } & {
+        nextKey?: Uint8Array;
+        total?: number;
+    } & { [K in Exclude<keyof I, keyof PageResponse>]: never; }>(object: I): PageResponse;
+};
+type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;
+export type DeepPartial<T> = T extends Builtin ? T : T extends Array<infer U> ? Array<DeepPartial<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>> : T extends {} ? {
+    [K in keyof T]?: DeepPartial<T[K]>;
+} : Partial<T>;
+type KeysOfUnion<T> = T extends T ? keyof T : never;
+export type Exact<P, I extends P> = P extends Builtin ? P : P & {
+    [K in keyof P]: Exact<P[K], I[K]>;
+} & {
+    [K in Exclude<keyof I, KeysOfUnion<P>>]: never;
+};
+export {};

package/types/iconlake.lake/types/gogoproto/gogo.d.ts

@@ -0,0 +1 @@
+export declare const protobufPackage = "gogoproto";

package/types/iconlake.lake/types/google/api/annotations.d.ts

@@ -0,0 +1 @@
+export declare const protobufPackage = "google.api";