@iconlake/client 1.3.0 → 1.5.0

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

@@ -0,0 +1,27 @@
+import _m0 from "protobufjs/minimal";
+export declare const protobufPackage = "iconlake.lake";
+export interface AllowedSender {
+    address: string;
+}
+export declare const AllowedSender: {
+    encode(message: AllowedSender, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): AllowedSender;
+    fromJSON(object: any): AllowedSender;
+    toJSON(message: AllowedSender): unknown;
+    fromPartial<I extends {
+        address?: string;
+    } & {
+        address?: string;
+    } & { [K in Exclude<keyof I, "address">]: never; }>(object: I): AllowedSender;
+};
+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/iconlake/lake/genesis.d.ts

@@ -0,0 +1,43 @@
+import _m0 from "protobufjs/minimal";
+import { AllowedSender } from "./allowed_sender";
+import { Params } from "./params";
+export declare const protobufPackage = "iconlake.lake";
+/** GenesisState defines the lake module's genesis state. */
+export interface GenesisState {
+    params: Params | undefined;
+    allowedSenderList: AllowedSender[];
+}
+export declare const GenesisState: {
+    encode(message: GenesisState, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): GenesisState;
+    fromJSON(object: any): GenesisState;
+    toJSON(message: GenesisState): unknown;
+    fromPartial<I extends {
+        params?: {};
+        allowedSenderList?: {
+            address?: string;
+        }[];
+    } & {
+        params?: {} & {} & { [K in Exclude<keyof I["params"], never>]: never; };
+        allowedSenderList?: {
+            address?: string;
+        }[] & ({
+            address?: string;
+        } & {
+            address?: string;
+        } & { [K_1 in Exclude<keyof I["allowedSenderList"][number], "address">]: never; })[] & { [K_2 in Exclude<keyof I["allowedSenderList"], keyof {
+            address?: string;
+        }[]>]: never; };
+    } & { [K_3 in Exclude<keyof I, keyof GenesisState>]: never; }>(object: I): GenesisState;
+};
+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/iconlake/lake/params.d.ts

@@ -0,0 +1,23 @@
+import _m0 from "protobufjs/minimal";
+export declare const protobufPackage = "iconlake.lake";
+/** Params defines the parameters for the module. */
+export interface Params {
+}
+export declare const Params: {
+    encode(_: Params, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): Params;
+    fromJSON(_: any): Params;
+    toJSON(_: Params): unknown;
+    fromPartial<I extends {} & {} & { [K in Exclude<keyof I, never>]: never; }>(_: I): Params;
+};
+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/iconlake/lake/query.d.ts

@@ -0,0 +1,162 @@
+import _m0 from "protobufjs/minimal";
+import { PageRequest, PageResponse } from "../../cosmos/base/query/v1beta1/pagination";
+import { AllowedSender } from "./allowed_sender";
+import { Params } from "./params";
+export declare const protobufPackage = "iconlake.lake";
+/** QueryParamsRequest is request type for the Query/Params RPC method. */
+export interface QueryParamsRequest {
+}
+/** QueryParamsResponse is response type for the Query/Params RPC method. */
+export interface QueryParamsResponse {
+    /** params holds all the parameters of this module. */
+    params: Params | undefined;
+}
+export interface QueryGetAllowedSenderRequest {
+    address: string;
+}
+export interface QueryGetAllowedSenderResponse {
+    allowedSender: AllowedSender | undefined;
+}
+export interface QueryAllAllowedSenderRequest {
+    pagination: PageRequest | undefined;
+}
+export interface QueryAllAllowedSenderResponse {
+    allowedSender: AllowedSender[];
+    pagination: PageResponse | undefined;
+}
+export declare const QueryParamsRequest: {
+    encode(_: QueryParamsRequest, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): QueryParamsRequest;
+    fromJSON(_: any): QueryParamsRequest;
+    toJSON(_: QueryParamsRequest): unknown;
+    fromPartial<I extends {} & {} & { [K in Exclude<keyof I, never>]: never; }>(_: I): QueryParamsRequest;
+};
+export declare const QueryParamsResponse: {
+    encode(message: QueryParamsResponse, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): QueryParamsResponse;
+    fromJSON(object: any): QueryParamsResponse;
+    toJSON(message: QueryParamsResponse): unknown;
+    fromPartial<I extends {
+        params?: {};
+    } & {
+        params?: {} & {} & { [K in Exclude<keyof I["params"], never>]: never; };
+    } & { [K_1 in Exclude<keyof I, "params">]: never; }>(object: I): QueryParamsResponse;
+};
+export declare const QueryGetAllowedSenderRequest: {
+    encode(message: QueryGetAllowedSenderRequest, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): QueryGetAllowedSenderRequest;
+    fromJSON(object: any): QueryGetAllowedSenderRequest;
+    toJSON(message: QueryGetAllowedSenderRequest): unknown;
+    fromPartial<I extends {
+        address?: string;
+    } & {
+        address?: string;
+    } & { [K in Exclude<keyof I, "address">]: never; }>(object: I): QueryGetAllowedSenderRequest;
+};
+export declare const QueryGetAllowedSenderResponse: {
+    encode(message: QueryGetAllowedSenderResponse, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): QueryGetAllowedSenderResponse;
+    fromJSON(object: any): QueryGetAllowedSenderResponse;
+    toJSON(message: QueryGetAllowedSenderResponse): unknown;
+    fromPartial<I extends {
+        allowedSender?: {
+            address?: string;
+        };
+    } & {
+        allowedSender?: {
+            address?: string;
+        } & {
+            address?: string;
+        } & { [K in Exclude<keyof I["allowedSender"], "address">]: never; };
+    } & { [K_1 in Exclude<keyof I, "allowedSender">]: never; }>(object: I): QueryGetAllowedSenderResponse;
+};
+export declare const QueryAllAllowedSenderRequest: {
+    encode(message: QueryAllAllowedSenderRequest, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): QueryAllAllowedSenderRequest;
+    fromJSON(object: any): QueryAllAllowedSenderRequest;
+    toJSON(message: QueryAllAllowedSenderRequest): unknown;
+    fromPartial<I extends {
+        pagination?: {
+            key?: Uint8Array;
+            offset?: number;
+            limit?: number;
+            countTotal?: boolean;
+            reverse?: boolean;
+        };
+    } & {
+        pagination?: {
+            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["pagination"], keyof PageRequest>]: never; };
+    } & { [K_1 in Exclude<keyof I, "pagination">]: never; }>(object: I): QueryAllAllowedSenderRequest;
+};
+export declare const QueryAllAllowedSenderResponse: {
+    encode(message: QueryAllAllowedSenderResponse, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): QueryAllAllowedSenderResponse;
+    fromJSON(object: any): QueryAllAllowedSenderResponse;
+    toJSON(message: QueryAllAllowedSenderResponse): unknown;
+    fromPartial<I extends {
+        allowedSender?: {
+            address?: string;
+        }[];
+        pagination?: {
+            nextKey?: Uint8Array;
+            total?: number;
+        };
+    } & {
+        allowedSender?: {
+            address?: string;
+        }[] & ({
+            address?: string;
+        } & {
+            address?: string;
+        } & { [K in Exclude<keyof I["allowedSender"][number], "address">]: never; })[] & { [K_1 in Exclude<keyof I["allowedSender"], keyof {
+            address?: string;
+        }[]>]: never; };
+        pagination?: {
+            nextKey?: Uint8Array;
+            total?: number;
+        } & {
+            nextKey?: Uint8Array;
+            total?: number;
+        } & { [K_2 in Exclude<keyof I["pagination"], keyof PageResponse>]: never; };
+    } & { [K_3 in Exclude<keyof I, keyof QueryAllAllowedSenderResponse>]: never; }>(object: I): QueryAllAllowedSenderResponse;
+};
+/** Query defines the gRPC querier service. */
+export interface Query {
+    /** Parameters queries the parameters of the module. */
+    Params(request: QueryParamsRequest): Promise<QueryParamsResponse>;
+    /** Queries a list of AllowedSender items. */
+    AllowedSender(request: QueryGetAllowedSenderRequest): Promise<QueryGetAllowedSenderResponse>;
+    AllowedSenderAll(request: QueryAllAllowedSenderRequest): Promise<QueryAllAllowedSenderResponse>;
+}
+export declare class QueryClientImpl implements Query {
+    private readonly rpc;
+    constructor(rpc: Rpc);
+    Params(request: QueryParamsRequest): Promise<QueryParamsResponse>;
+    AllowedSender(request: QueryGetAllowedSenderRequest): Promise<QueryGetAllowedSenderResponse>;
+    AllowedSenderAll(request: QueryAllAllowedSenderRequest): Promise<QueryAllAllowedSenderResponse>;
+}
+interface Rpc {
+    request(service: string, method: string, data: Uint8Array): Promise<Uint8Array>;
+}
+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/iconlake/lake/tx.d.ts

@@ -0,0 +1,103 @@
+import _m0 from "protobufjs/minimal";
+export declare const protobufPackage = "iconlake.lake";
+export interface MsgCreateAllowedSender {
+    creator: string;
+    address: string;
+}
+export interface MsgCreateAllowedSenderResponse {
+}
+export interface MsgDeleteAllowedSender {
+    creator: string;
+    address: string;
+}
+export interface MsgDeleteAllowedSenderResponse {
+}
+export declare const MsgCreateAllowedSender: {
+    encode(message: MsgCreateAllowedSender, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): MsgCreateAllowedSender;
+    fromJSON(object: any): MsgCreateAllowedSender;
+    toJSON(message: MsgCreateAllowedSender): unknown;
+    fromPartial<I extends {
+        creator?: string;
+        address?: string;
+    } & {
+        creator?: string;
+        address?: string;
+    } & { [K in Exclude<keyof I, keyof MsgCreateAllowedSender>]: never; }>(object: I): MsgCreateAllowedSender;
+};
+export declare const MsgCreateAllowedSenderResponse: {
+    encode(_: MsgCreateAllowedSenderResponse, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): MsgCreateAllowedSenderResponse;
+    fromJSON(_: any): MsgCreateAllowedSenderResponse;
+    toJSON(_: MsgCreateAllowedSenderResponse): unknown;
+    fromPartial<I extends {} & {} & { [K in Exclude<keyof I, never>]: never; }>(_: I): MsgCreateAllowedSenderResponse;
+};
+export declare const MsgDeleteAllowedSender: {
+    encode(message: MsgDeleteAllowedSender, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): MsgDeleteAllowedSender;
+    fromJSON(object: any): MsgDeleteAllowedSender;
+    toJSON(message: MsgDeleteAllowedSender): unknown;
+    fromPartial<I extends {
+        creator?: string;
+        address?: string;
+    } & {
+        creator?: string;
+        address?: string;
+    } & { [K in Exclude<keyof I, keyof MsgDeleteAllowedSender>]: never; }>(object: I): MsgDeleteAllowedSender;
+};
+export declare const MsgDeleteAllowedSenderResponse: {
+    encode(_: MsgDeleteAllowedSenderResponse, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): MsgDeleteAllowedSenderResponse;
+    fromJSON(_: any): MsgDeleteAllowedSenderResponse;
+    toJSON(_: MsgDeleteAllowedSenderResponse): unknown;
+    fromPartial<I extends {} & {} & { [K in Exclude<keyof I, never>]: never; }>(_: I): MsgDeleteAllowedSenderResponse;
+};
+/** Msg defines the Msg service. */
+export interface Msg {
+    CreateAllowedSender(request: MsgCreateAllowedSender): Promise<MsgCreateAllowedSenderResponse>;
+    DeleteAllowedSender(request: MsgDeleteAllowedSender): Promise<MsgDeleteAllowedSenderResponse>;
+}
+export declare class MsgClientImpl implements Msg {
+    private readonly rpc;
+    constructor(rpc: Rpc);
+    CreateAllowedSender(request: MsgCreateAllowedSender): Promise<MsgCreateAllowedSenderResponse>;
+    DeleteAllowedSender(request: MsgDeleteAllowedSender): Promise<MsgDeleteAllowedSenderResponse>;
+}
+interface Rpc {
+    request(service: string, method: string, data: Uint8Array): Promise<Uint8Array>;
+}
+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 declare const createLakeAminoConverters: () => {
+    "/iconlake.lake.MsgCreateAllowedSender": {
+        aminoType: string;
+        toAmino: (msg: MsgCreateAllowedSender) => {
+            creator: string;
+            address: string;
+        };
+        fromAmino: (obj: any) => {
+            creator: any;
+            address: any;
+        };
+    };
+    "/iconlake.lake.MsgDeleteAllowedSender": {
+        aminoType: string;
+        toAmino: (msg: MsgDeleteAllowedSender) => {
+            creator: string;
+            address: string;
+        };
+        fromAmino: (obj: any) => {
+            creator: any;
+            address: any;
+        };
+    };
+};
+export {};

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

@@ -0,0 +1,3 @@
+import { AllowedSender } from "./types/iconlake/lake/allowed_sender";
+import { Params } from "./types/iconlake/lake/params";
+export { AllowedSender, Params, };

package/types/iconlake.license/index.d.ts

@@ -0,0 +1,5 @@
+import Module from './module';
+import { txClient, queryClient, registry } from './module';
+import { msgTypes } from './registry';
+export * from "./types";
+export { Module, msgTypes, txClient, queryClient, registry };

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

@@ -0,0 +1,77 @@
+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 { MsgUpdateLicenseTemplate } from "./types/iconlake/license/tx";
+import { MsgCreateLicenseTemplate } from "./types/iconlake/license/tx";
+import { MsgBuyLicense } from "./types/iconlake/license/tx";
+import { MsgDeleteLicenseTemplate } from "./types/iconlake/license/tx";
+export { MsgUpdateLicenseTemplate, MsgCreateLicenseTemplate, MsgBuyLicense, MsgDeleteLicenseTemplate };
+type sendMsgUpdateLicenseTemplateParams = {
+    value: MsgUpdateLicenseTemplate;
+    fee?: StdFee;
+    memo?: string;
+};
+type sendMsgCreateLicenseTemplateParams = {
+    value: MsgCreateLicenseTemplate;
+    fee?: StdFee;
+    memo?: string;
+};
+type sendMsgBuyLicenseParams = {
+    value: MsgBuyLicense;
+    fee?: StdFee;
+    memo?: string;
+};
+type sendMsgDeleteLicenseTemplateParams = {
+    value: MsgDeleteLicenseTemplate;
+    fee?: StdFee;
+    memo?: string;
+};
+type msgUpdateLicenseTemplateParams = {
+    value: MsgUpdateLicenseTemplate;
+};
+type msgCreateLicenseTemplateParams = {
+    value: MsgCreateLicenseTemplate;
+};
+type msgBuyLicenseParams = {
+    value: MsgBuyLicense;
+};
+type msgDeleteLicenseTemplateParams = {
+    value: MsgDeleteLicenseTemplate;
+};
+export declare const registry: Registry;
+interface TxClientOptions {
+    addr: string;
+    prefix: string;
+    signer?: OfflineSigner;
+}
+export declare const txClient: ({ signer, prefix, addr }?: TxClientOptions) => {
+    sendMsgUpdateLicenseTemplate({ value, fee, memo }: sendMsgUpdateLicenseTemplateParams): Promise<DeliverTxResponse>;
+    sendMsgCreateLicenseTemplate({ value, fee, memo }: sendMsgCreateLicenseTemplateParams): Promise<DeliverTxResponse>;
+    sendMsgBuyLicense({ value, fee, memo }: sendMsgBuyLicenseParams): Promise<DeliverTxResponse>;
+    sendMsgDeleteLicenseTemplate({ value, fee, memo }: sendMsgDeleteLicenseTemplateParams): Promise<DeliverTxResponse>;
+    msgUpdateLicenseTemplate({ value }: msgUpdateLicenseTemplateParams): EncodeObject;
+    msgCreateLicenseTemplate({ value }: msgCreateLicenseTemplateParams): EncodeObject;
+    msgBuyLicense({ value }: msgBuyLicenseParams): EncodeObject;
+    msgDeleteLicenseTemplate({ value }: msgDeleteLicenseTemplateParams): 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: {
+        IconlakeLicense: SDKModule;
+    };
+    registry: [string, GeneratedType][];
+};
+export default Module;

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

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