@0xkaleab/sdk-js 0.2.7

package/dist/types/codegen/google/type/quaternion.d.ts

@@ -0,0 +1,241 @@
+import { BinaryReader, BinaryWriter } from "../../binary";
+import { DeepPartial } from "../../helpers";
+/**
+ * A quaternion is defined as the quotient of two directed lines in a
+ * three-dimensional space or equivalently as the quotient of two Euclidean
+ * vectors (https://en.wikipedia.org/wiki/Quaternion).
+ *
+ * Quaternions are often used in calculations involving three-dimensional
+ * rotations (https://en.wikipedia.org/wiki/Quaternions_and_spatial_rotation),
+ * as they provide greater mathematical robustness by avoiding the gimbal lock
+ * problems that can be encountered when using Euler angles
+ * (https://en.wikipedia.org/wiki/Gimbal_lock).
+ *
+ * Quaternions are generally represented in this form:
+ *
+ *     w + xi + yj + zk
+ *
+ * where x, y, z, and w are real numbers, and i, j, and k are three imaginary
+ * numbers.
+ *
+ * Our naming choice `(x, y, z, w)` comes from the desire to avoid confusion for
+ * those interested in the geometric properties of the quaternion in the 3D
+ * Cartesian space. Other texts often use alternative names or subscripts, such
+ * as `(a, b, c, d)`, `(1, i, j, k)`, or `(0, 1, 2, 3)`, which are perhaps
+ * better suited for mathematical interpretations.
+ *
+ * To avoid any confusion, as well as to maintain compatibility with a large
+ * number of software libraries, the quaternions represented using the protocol
+ * buffer below *must* follow the Hamilton convention, which defines `ij = k`
+ * (i.e. a right-handed algebra), and therefore:
+ *
+ *     i^2 = j^2 = k^2 = ijk = −1
+ *     ij = −ji = k
+ *     jk = −kj = i
+ *     ki = −ik = j
+ *
+ * Please DO NOT use this to represent quaternions that follow the JPL
+ * convention, or any of the other quaternion flavors out there.
+ *
+ * Definitions:
+ *
+ *   - Quaternion norm (or magnitude): `sqrt(x^2 + y^2 + z^2 + w^2)`.
+ *   - Unit (or normalized) quaternion: a quaternion whose norm is 1.
+ *   - Pure quaternion: a quaternion whose scalar component (`w`) is 0.
+ *   - Rotation quaternion: a unit quaternion used to represent rotation.
+ *   - Orientation quaternion: a unit quaternion used to represent orientation.
+ *
+ * A quaternion can be normalized by dividing it by its norm. The resulting
+ * quaternion maintains the same direction, but has a norm of 1, i.e. it moves
+ * on the unit sphere. This is generally necessary for rotation and orientation
+ * quaternions, to avoid rounding errors:
+ * https://en.wikipedia.org/wiki/Rotation_formalisms_in_three_dimensions
+ *
+ * Note that `(x, y, z, w)` and `(-x, -y, -z, -w)` represent the same rotation,
+ * but normalization would be even more useful, e.g. for comparison purposes, if
+ * it would produce a unique representation. It is thus recommended that `w` be
+ * kept positive, which can be achieved by changing all the signs when `w` is
+ * negative.
+ * @name Quaternion
+ * @package google.type
+ * @see proto type: google.type.Quaternion
+ */
+export interface Quaternion {
+    /**
+     * The x component.
+     */
+    x: number;
+    /**
+     * The y component.
+     */
+    y: number;
+    /**
+     * The z component.
+     */
+    z: number;
+    /**
+     * The scalar component.
+     */
+    w: number;
+}
+export interface QuaternionProtoMsg {
+    typeUrl: "/google.type.Quaternion";
+    value: Uint8Array;
+}
+/**
+ * A quaternion is defined as the quotient of two directed lines in a
+ * three-dimensional space or equivalently as the quotient of two Euclidean
+ * vectors (https://en.wikipedia.org/wiki/Quaternion).
+ *
+ * Quaternions are often used in calculations involving three-dimensional
+ * rotations (https://en.wikipedia.org/wiki/Quaternions_and_spatial_rotation),
+ * as they provide greater mathematical robustness by avoiding the gimbal lock
+ * problems that can be encountered when using Euler angles
+ * (https://en.wikipedia.org/wiki/Gimbal_lock).
+ *
+ * Quaternions are generally represented in this form:
+ *
+ *     w + xi + yj + zk
+ *
+ * where x, y, z, and w are real numbers, and i, j, and k are three imaginary
+ * numbers.
+ *
+ * Our naming choice `(x, y, z, w)` comes from the desire to avoid confusion for
+ * those interested in the geometric properties of the quaternion in the 3D
+ * Cartesian space. Other texts often use alternative names or subscripts, such
+ * as `(a, b, c, d)`, `(1, i, j, k)`, or `(0, 1, 2, 3)`, which are perhaps
+ * better suited for mathematical interpretations.
+ *
+ * To avoid any confusion, as well as to maintain compatibility with a large
+ * number of software libraries, the quaternions represented using the protocol
+ * buffer below *must* follow the Hamilton convention, which defines `ij = k`
+ * (i.e. a right-handed algebra), and therefore:
+ *
+ *     i^2 = j^2 = k^2 = ijk = −1
+ *     ij = −ji = k
+ *     jk = −kj = i
+ *     ki = −ik = j
+ *
+ * Please DO NOT use this to represent quaternions that follow the JPL
+ * convention, or any of the other quaternion flavors out there.
+ *
+ * Definitions:
+ *
+ *   - Quaternion norm (or magnitude): `sqrt(x^2 + y^2 + z^2 + w^2)`.
+ *   - Unit (or normalized) quaternion: a quaternion whose norm is 1.
+ *   - Pure quaternion: a quaternion whose scalar component (`w`) is 0.
+ *   - Rotation quaternion: a unit quaternion used to represent rotation.
+ *   - Orientation quaternion: a unit quaternion used to represent orientation.
+ *
+ * A quaternion can be normalized by dividing it by its norm. The resulting
+ * quaternion maintains the same direction, but has a norm of 1, i.e. it moves
+ * on the unit sphere. This is generally necessary for rotation and orientation
+ * quaternions, to avoid rounding errors:
+ * https://en.wikipedia.org/wiki/Rotation_formalisms_in_three_dimensions
+ *
+ * Note that `(x, y, z, w)` and `(-x, -y, -z, -w)` represent the same rotation,
+ * but normalization would be even more useful, e.g. for comparison purposes, if
+ * it would produce a unique representation. It is thus recommended that `w` be
+ * kept positive, which can be achieved by changing all the signs when `w` is
+ * negative.
+ * @name QuaternionAmino
+ * @package google.type
+ * @see proto type: google.type.Quaternion
+ */
+export interface QuaternionAmino {
+    /**
+     * The x component.
+     */
+    x: number;
+    /**
+     * The y component.
+     */
+    y: number;
+    /**
+     * The z component.
+     */
+    z: number;
+    /**
+     * The scalar component.
+     */
+    w: number;
+}
+export interface QuaternionAminoMsg {
+    type: "/google.type.Quaternion";
+    value: QuaternionAmino;
+}
+/**
+ * A quaternion is defined as the quotient of two directed lines in a
+ * three-dimensional space or equivalently as the quotient of two Euclidean
+ * vectors (https://en.wikipedia.org/wiki/Quaternion).
+ *
+ * Quaternions are often used in calculations involving three-dimensional
+ * rotations (https://en.wikipedia.org/wiki/Quaternions_and_spatial_rotation),
+ * as they provide greater mathematical robustness by avoiding the gimbal lock
+ * problems that can be encountered when using Euler angles
+ * (https://en.wikipedia.org/wiki/Gimbal_lock).
+ *
+ * Quaternions are generally represented in this form:
+ *
+ *     w + xi + yj + zk
+ *
+ * where x, y, z, and w are real numbers, and i, j, and k are three imaginary
+ * numbers.
+ *
+ * Our naming choice `(x, y, z, w)` comes from the desire to avoid confusion for
+ * those interested in the geometric properties of the quaternion in the 3D
+ * Cartesian space. Other texts often use alternative names or subscripts, such
+ * as `(a, b, c, d)`, `(1, i, j, k)`, or `(0, 1, 2, 3)`, which are perhaps
+ * better suited for mathematical interpretations.
+ *
+ * To avoid any confusion, as well as to maintain compatibility with a large
+ * number of software libraries, the quaternions represented using the protocol
+ * buffer below *must* follow the Hamilton convention, which defines `ij = k`
+ * (i.e. a right-handed algebra), and therefore:
+ *
+ *     i^2 = j^2 = k^2 = ijk = −1
+ *     ij = −ji = k
+ *     jk = −kj = i
+ *     ki = −ik = j
+ *
+ * Please DO NOT use this to represent quaternions that follow the JPL
+ * convention, or any of the other quaternion flavors out there.
+ *
+ * Definitions:
+ *
+ *   - Quaternion norm (or magnitude): `sqrt(x^2 + y^2 + z^2 + w^2)`.
+ *   - Unit (or normalized) quaternion: a quaternion whose norm is 1.
+ *   - Pure quaternion: a quaternion whose scalar component (`w`) is 0.
+ *   - Rotation quaternion: a unit quaternion used to represent rotation.
+ *   - Orientation quaternion: a unit quaternion used to represent orientation.
+ *
+ * A quaternion can be normalized by dividing it by its norm. The resulting
+ * quaternion maintains the same direction, but has a norm of 1, i.e. it moves
+ * on the unit sphere. This is generally necessary for rotation and orientation
+ * quaternions, to avoid rounding errors:
+ * https://en.wikipedia.org/wiki/Rotation_formalisms_in_three_dimensions
+ *
+ * Note that `(x, y, z, w)` and `(-x, -y, -z, -w)` represent the same rotation,
+ * but normalization would be even more useful, e.g. for comparison purposes, if
+ * it would produce a unique representation. It is thus recommended that `w` be
+ * kept positive, which can be achieved by changing all the signs when `w` is
+ * negative.
+ * @name Quaternion
+ * @package google.type
+ * @see proto type: google.type.Quaternion
+ */
+export declare const Quaternion: {
+    typeUrl: string;
+    is(o: any): o is Quaternion;
+    isAmino(o: any): o is QuaternionAmino;
+    encode(message: Quaternion, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): Quaternion;
+    fromPartial(object: DeepPartial<Quaternion>): Quaternion;
+    fromAmino(object: QuaternionAmino): Quaternion;
+    toAmino(message: Quaternion): QuaternionAmino;
+    fromAminoMsg(object: QuaternionAminoMsg): Quaternion;
+    fromProtoMsg(message: QuaternionProtoMsg): Quaternion;
+    toProto(message: Quaternion): Uint8Array;
+    toProtoMsg(message: Quaternion): QuaternionProtoMsg;
+    registerTypeUrl(): void;
+};

package/dist/types/codegen/google/type/timeofday.d.ts

@@ -0,0 +1,92 @@
+import { BinaryReader, BinaryWriter } from "../../binary";
+import { DeepPartial } from "../../helpers";
+/**
+ * Represents a time of day. The date and time zone are either not significant
+ * or are specified elsewhere. An API may choose to allow leap seconds. Related
+ * types are [google.type.Date][google.type.Date] and
+ * `google.protobuf.Timestamp`.
+ * @name TimeOfDay
+ * @package google.type
+ * @see proto type: google.type.TimeOfDay
+ */
+export interface TimeOfDay {
+    /**
+     * Hours of day in 24 hour format. Should be from 0 to 23. An API may choose
+     * to allow the value "24:00:00" for scenarios like business closing time.
+     */
+    hours: number;
+    /**
+     * Minutes of hour of day. Must be from 0 to 59.
+     */
+    minutes: number;
+    /**
+     * Seconds of minutes of the time. Must normally be from 0 to 59. An API may
+     * allow the value 60 if it allows leap-seconds.
+     */
+    seconds: number;
+    /**
+     * Fractions of seconds in nanoseconds. Must be from 0 to 999,999,999.
+     */
+    nanos: number;
+}
+export interface TimeOfDayProtoMsg {
+    typeUrl: "/google.type.TimeOfDay";
+    value: Uint8Array;
+}
+/**
+ * Represents a time of day. The date and time zone are either not significant
+ * or are specified elsewhere. An API may choose to allow leap seconds. Related
+ * types are [google.type.Date][google.type.Date] and
+ * `google.protobuf.Timestamp`.
+ * @name TimeOfDayAmino
+ * @package google.type
+ * @see proto type: google.type.TimeOfDay
+ */
+export interface TimeOfDayAmino {
+    /**
+     * Hours of day in 24 hour format. Should be from 0 to 23. An API may choose
+     * to allow the value "24:00:00" for scenarios like business closing time.
+     */
+    hours: number;
+    /**
+     * Minutes of hour of day. Must be from 0 to 59.
+     */
+    minutes: number;
+    /**
+     * Seconds of minutes of the time. Must normally be from 0 to 59. An API may
+     * allow the value 60 if it allows leap-seconds.
+     */
+    seconds: number;
+    /**
+     * Fractions of seconds in nanoseconds. Must be from 0 to 999,999,999.
+     */
+    nanos: number;
+}
+export interface TimeOfDayAminoMsg {
+    type: "/google.type.TimeOfDay";
+    value: TimeOfDayAmino;
+}
+/**
+ * Represents a time of day. The date and time zone are either not significant
+ * or are specified elsewhere. An API may choose to allow leap seconds. Related
+ * types are [google.type.Date][google.type.Date] and
+ * `google.protobuf.Timestamp`.
+ * @name TimeOfDay
+ * @package google.type
+ * @see proto type: google.type.TimeOfDay
+ */
+export declare const TimeOfDay: {
+    typeUrl: string;
+    is(o: any): o is TimeOfDay;
+    isAmino(o: any): o is TimeOfDayAmino;
+    encode(message: TimeOfDay, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): TimeOfDay;
+    fromPartial(object: DeepPartial<TimeOfDay>): TimeOfDay;
+    fromAmino(object: TimeOfDayAmino): TimeOfDay;
+    toAmino(message: TimeOfDay): TimeOfDayAmino;
+    fromAminoMsg(object: TimeOfDayAminoMsg): TimeOfDay;
+    fromProtoMsg(message: TimeOfDayProtoMsg): TimeOfDay;
+    toProto(message: TimeOfDay): Uint8Array;
+    toProtoMsg(message: TimeOfDay): TimeOfDayProtoMsg;
+    registerTypeUrl(): void;
+};

package/dist/types/codegen/helper-func-types.d.ts

@@ -0,0 +1,40 @@
+/**
+* This file and any referenced files were automatically generated by @hyperweb/telescope@2.0.3
+* DO NOT MODIFY BY HAND. Instead, download the latest proto files for your chain
+* and run the transpile command or npm scripts command that is used to regenerate this bundle.
+*/
+import { HttpEndpoint } from "@interchainjs/types";
+import { BinaryReader, BinaryWriter } from "./binary";
+import { Rpc } from "./helpers";
+import { TelescopeGeneratedCodec, DeliverTxResponse, StdFee } from "./types";
+import { ISigningClient } from "@interchainjs/cosmos";
+export interface QueryBuilderOptions<TReq, TRes> {
+    encode: (request: TReq, writer?: BinaryWriter) => BinaryWriter;
+    decode: (input: BinaryReader | Uint8Array, length?: number) => TRes;
+    service: string;
+    method: string;
+    deps?: TelescopeGeneratedCodec<any, any, any>[];
+}
+export declare function buildQuery<TReq, TRes>(opts: QueryBuilderOptions<TReq, TRes>): (client: EndpointOrRpc, request: TReq) => Promise<TRes>;
+export interface ITxArgs<TMsg> {
+    signerAddress: string;
+    message: TMsg | TMsg[];
+    fee: StdFee | 'auto';
+    memo: string;
+}
+export interface TxBuilderOptions {
+    msg: TelescopeGeneratedCodec<any, any, any>;
+}
+export declare function buildTx<TMsg>(opts: TxBuilderOptions): (client: ISigningClient, signerAddress: string, message: TMsg | TMsg[], fee: StdFee | "auto", memo: string) => Promise<DeliverTxResponse>;
+export interface Encoder {
+    typeUrl: string;
+    fromPartial: (data: any) => any;
+    encode: (data: any) => Uint8Array;
+}
+export interface AminoConverter {
+    typeUrl: string;
+    aminoType: string;
+    fromAmino: (data: any) => any;
+    toAmino: (data: any) => any;
+}
+export type EndpointOrRpc = string | HttpEndpoint | Rpc;

package/dist/types/codegen/helpers.d.ts

@@ -0,0 +1,80 @@
+/**
+* This file and any referenced files were automatically generated by @hyperweb/telescope@2.0.3
+* DO NOT MODIFY BY HAND. Instead, download the latest proto files for your chain
+* and run the transpile command or npm scripts command that is used to regenerate this bundle.
+*/
+export { fromBase64 as bytesFromBase64, toBase64 as base64FromBytes } from '@interchainjs/encoding';
+export interface AminoHeight {
+    readonly revision_number?: string;
+    readonly revision_height?: string;
+}
+export declare function omitDefault<T extends string | number | bigint | boolean>(input: T): T | undefined;
+interface Duration {
+    /**
+     * Signed seconds of the span of time. Must be from -315,576,000,000
+     * to +315,576,000,000 inclusive. Note: these bounds are computed from:
+     * 60 sec/min * 60 min/hr * 24 hr/day * 365.25 days/year * 10000 years
+     */
+    seconds: bigint;
+    /**
+     * Signed fractions of a second at nanosecond resolution of the span
+     * of time. Durations less than one second are represented with a 0
+     * `seconds` field and a positive or negative `nanos` field. For durations
+     * of one second or more, a non-zero value for the `nanos` field must be
+     * of the same sign as the `seconds` field. Must be from -999,999,999
+     * to +999,999,999 inclusive.
+     */
+    nanos: number;
+}
+export declare function toDuration(duration: string): Duration;
+export declare function fromDuration(duration: Duration): string;
+export declare function isSet(value: any): boolean;
+export declare function isObject(value: any): boolean;
+export interface PageRequest {
+    key: Uint8Array;
+    offset: bigint;
+    limit: bigint;
+    countTotal: boolean;
+    reverse: boolean;
+}
+export interface PageRequestParams {
+    'pagination.key'?: string;
+    'pagination.offset'?: string;
+    'pagination.limit'?: string;
+    'pagination.count_total'?: boolean;
+    'pagination.reverse'?: boolean;
+}
+export interface Params {
+    params: PageRequestParams;
+}
+export declare const setPaginationParams: (options: Params, pagination?: PageRequest) => Params;
+type Builtin = Date | Function | Uint8Array | string | number | bigint | 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]>;
+} & Record<Exclude<keyof I, KeysOfUnion<P>>, never>;
+export interface Rpc {
+    request(service: string, method: string, data: Uint8Array): Promise<Uint8Array>;
+}
+export declare function isRpc(rpc: unknown): rpc is Rpc;
+interface Timestamp {
+    /**
+     * Represents seconds of UTC time since Unix epoch
+     * 1970-01-01T00:00:00Z. Must be from 0001-01-01T00:00:00Z to
+     * 9999-12-31T23:59:59Z inclusive.
+     */
+    seconds: bigint;
+    /**
+     * Non-negative fractions of a second at nanosecond resolution. Negative
+     * second values with fractions must still have non-negative nanos values
+     * that count forward in time. Must be from 0 to 999,999,999
+     * inclusive.
+     */
+    nanos: number;
+}
+export declare function toTimestamp(date: Date): Timestamp;
+export declare function fromTimestamp(t: Timestamp): Date;
+export declare function fromJsonTimestamp(o: any): Timestamp;

package/dist/types/codegen/index.d.ts

@@ -0,0 +1,21 @@
+/**
+  * This file and any referenced files were automatically generated by @hyperweb/telescope@2.0.3
+  * DO NOT MODIFY BY HAND. Instead, download the latest proto files for your chain
+    * and run the transpile command or npm scripts command that is used to regenerate this bundle.
+  */
+export * from "./tendermint/bundle";
+export * from "./lumera/bundle";
+export * from "./lumera/client";
+export * from "./google/bundle";
+export * from "./gogoproto/bundle";
+export * from "./cosmos_proto/bundle";
+export * from "./cosmos/bundle";
+export * from "./cosmos/client";
+export * from "./amino/bundle";
+export * from "./extern";
+export * from "./helper-func-types";
+export * from "./varint";
+export * from "./utf8";
+export * from "./binary";
+export * from "./types";
+export * from "./registry";

package/dist/types/codegen/lumera/action/module/v1/module.d.ts

@@ -0,0 +1,55 @@
+import { BinaryReader, BinaryWriter } from "../../../../binary";
+import { DeepPartial } from "../../../../helpers";
+/**
+ * Module is the config object for the module.
+ * @name Module
+ * @package lumera.action.module.v1
+ * @see proto type: lumera.action.module.v1.Module
+ */
+export interface Module {
+    /**
+     * authority defines the custom module authority. If not set, defaults to the governance module.
+     */
+    authority: string;
+}
+export interface ModuleProtoMsg {
+    typeUrl: "/lumera.action.module.v1.Module";
+    value: Uint8Array;
+}
+/**
+ * Module is the config object for the module.
+ * @name ModuleAmino
+ * @package lumera.action.module.v1
+ * @see proto type: lumera.action.module.v1.Module
+ */
+export interface ModuleAmino {
+    /**
+     * authority defines the custom module authority. If not set, defaults to the governance module.
+     */
+    authority: string;
+}
+export interface ModuleAminoMsg {
+    type: "/lumera.action.module.v1.Module";
+    value: ModuleAmino;
+}
+/**
+ * Module is the config object for the module.
+ * @name Module
+ * @package lumera.action.module.v1
+ * @see proto type: lumera.action.module.v1.Module
+ */
+export declare const Module: {
+    typeUrl: string;
+    is(o: any): o is Module;
+    isAmino(o: any): o is ModuleAmino;
+    encode(message: Module, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): Module;
+    fromPartial(object: DeepPartial<Module>): Module;
+    fromAmino(object: ModuleAmino): Module;
+    toAmino(message: Module): ModuleAmino;
+    fromAminoMsg(object: ModuleAminoMsg): Module;
+    fromProtoMsg(message: ModuleProtoMsg): Module;
+    toProto(message: Module): Uint8Array;
+    toProtoMsg(message: Module): ModuleProtoMsg;
+    registerTypeUrl(): void;
+};

package/dist/types/codegen/lumera/action/v1/action.d.ts

@@ -0,0 +1,69 @@
+import { ActionType } from "./action_type";
+import { ActionState } from "./action_state";
+import { DeepPartial } from "../../../helpers";
+import { BinaryReader, BinaryWriter } from "../../../binary";
+/**
+ * Action represents a specific action within the Lumera protocol.
+ * @name Action
+ * @package lumera.action.v1
+ * @see proto type: lumera.action.v1.Action
+ */
+export interface Action {
+    creator: string;
+    actionID: string;
+    actionType: ActionType;
+    metadata: Uint8Array;
+    price: string;
+    expirationTime: bigint;
+    state: ActionState;
+    blockHeight: bigint;
+    superNodes: string[];
+    fileSizeKbs: bigint;
+}
+export interface ActionProtoMsg {
+    typeUrl: "/lumera.action.v1.Action";
+    value: Uint8Array;
+}
+/**
+ * Action represents a specific action within the Lumera protocol.
+ * @name ActionAmino
+ * @package lumera.action.v1
+ * @see proto type: lumera.action.v1.Action
+ */
+export interface ActionAmino {
+    creator: string;
+    actionID: string;
+    actionType: ActionType;
+    metadata: string;
+    price: string;
+    expirationTime: string;
+    state: ActionState;
+    blockHeight: string;
+    superNodes: string[];
+    fileSizeKbs: string;
+}
+export interface ActionAminoMsg {
+    type: "/lumera.action.v1.Action";
+    value: ActionAmino;
+}
+/**
+ * Action represents a specific action within the Lumera protocol.
+ * @name Action
+ * @package lumera.action.v1
+ * @see proto type: lumera.action.v1.Action
+ */
+export declare const Action: {
+    typeUrl: string;
+    is(o: any): o is Action;
+    isAmino(o: any): o is ActionAmino;
+    encode(message: Action, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): Action;
+    fromPartial(object: DeepPartial<Action>): Action;
+    fromAmino(object: ActionAmino): Action;
+    toAmino(message: Action): ActionAmino;
+    fromAminoMsg(object: ActionAminoMsg): Action;
+    fromProtoMsg(message: ActionProtoMsg): Action;
+    toProto(message: Action): Uint8Array;
+    toProtoMsg(message: Action): ActionProtoMsg;
+    registerTypeUrl(): void;
+};

package/dist/types/codegen/lumera/action/v1/action_state.d.ts

@@ -0,0 +1,23 @@
+/** ActionState enum represents the various states an action can be in. */
+export declare enum ActionState {
+    /** ACTION_STATE_UNSPECIFIED - The default state, used when the state is not specified. */
+    ACTION_STATE_UNSPECIFIED = 0,
+    /** ACTION_STATE_PENDING - The action is pending and has not yet been processed. */
+    ACTION_STATE_PENDING = 1,
+    /** ACTION_STATE_PROCESSING - The action is currently being processed. */
+    ACTION_STATE_PROCESSING = 2,
+    /** ACTION_STATE_DONE - The action has been completed successfully. */
+    ACTION_STATE_DONE = 3,
+    /** ACTION_STATE_APPROVED - The action has been approved. */
+    ACTION_STATE_APPROVED = 4,
+    /** ACTION_STATE_REJECTED - The action has been rejected. */
+    ACTION_STATE_REJECTED = 5,
+    /** ACTION_STATE_FAILED - The action has failed. */
+    ACTION_STATE_FAILED = 6,
+    /** ACTION_STATE_EXPIRED - The action has expired and is no longer valid. */
+    ACTION_STATE_EXPIRED = 7,
+    UNRECOGNIZED = -1
+}
+export declare const ActionStateAmino: typeof ActionState;
+export declare function actionStateFromJSON(object: any): ActionState;
+export declare function actionStateToJSON(object: ActionState): string;

package/dist/types/codegen/lumera/action/v1/action_type.d.ts

@@ -0,0 +1,13 @@
+/** ActionType enum represents the various types of actions that can be performed. */
+export declare enum ActionType {
+    /** ACTION_TYPE_UNSPECIFIED - The default action type, used when the type is not specified. */
+    ACTION_TYPE_UNSPECIFIED = 0,
+    /** ACTION_TYPE_SENSE - The action type for sense operations. */
+    ACTION_TYPE_SENSE = 1,
+    /** ACTION_TYPE_CASCADE - The action type for cascade operations. */
+    ACTION_TYPE_CASCADE = 2,
+    UNRECOGNIZED = -1
+}
+export declare const ActionTypeAmino: typeof ActionType;
+export declare function actionTypeFromJSON(object: any): ActionType;
+export declare function actionTypeToJSON(object: ActionType): string;