@sparkdreamnft/sparkdreamjs 0.0.28 → 0.0.29

package/akash/base/attributes/v1/attribute.d.ts

@@ -0,0 +1,185 @@
+import { BinaryReader, BinaryWriter } from "../../../../binary";
+import { DeepPartial } from "../../../../helpers";
+/**
+ * Attribute represents an arbitrary attribute key-value pair.
+ * @name Attribute
+ * @package akash.base.attributes.v1
+ * @see proto type: akash.base.attributes.v1.Attribute
+ */
+export interface Attribute {
+    /**
+     * Key of the attribute (e.g., "region", "cpu_architecture", etc.).
+     */
+    key: string;
+    /**
+     * Value of the attribute (e.g., "us-west", "x86_64", etc.).
+     */
+    value: string;
+}
+export interface AttributeProtoMsg {
+    typeUrl: "/akash.base.attributes.v1.Attribute";
+    value: Uint8Array;
+}
+/**
+ * Attribute represents an arbitrary attribute key-value pair.
+ * @name AttributeAmino
+ * @package akash.base.attributes.v1
+ * @see proto type: akash.base.attributes.v1.Attribute
+ */
+export interface AttributeAmino {
+    /**
+     * Key of the attribute (e.g., "region", "cpu_architecture", etc.).
+     */
+    key?: string;
+    /**
+     * Value of the attribute (e.g., "us-west", "x86_64", etc.).
+     */
+    value?: string;
+}
+export interface AttributeAminoMsg {
+    type: "/akash.base.attributes.v1.Attribute";
+    value: AttributeAmino;
+}
+/**
+ * SignedBy represents validation accounts that tenant expects signatures for provider attributes.
+ * AllOf has precedence i.e. if there is at least one entry AnyOf is ignored regardless to how many
+ * entries there.
+ * @name SignedBy
+ * @package akash.base.attributes.v1
+ * @see proto type: akash.base.attributes.v1.SignedBy
+ */
+export interface SignedBy {
+    /**
+     * AllOf indicates all keys in this list must have signed attributes.
+     */
+    allOf: string[];
+    /**
+     * AnyOf means that at least of of the keys from the list must have signed attributes.
+     */
+    anyOf: string[];
+}
+export interface SignedByProtoMsg {
+    typeUrl: "/akash.base.attributes.v1.SignedBy";
+    value: Uint8Array;
+}
+/**
+ * SignedBy represents validation accounts that tenant expects signatures for provider attributes.
+ * AllOf has precedence i.e. if there is at least one entry AnyOf is ignored regardless to how many
+ * entries there.
+ * @name SignedByAmino
+ * @package akash.base.attributes.v1
+ * @see proto type: akash.base.attributes.v1.SignedBy
+ */
+export interface SignedByAmino {
+    /**
+     * AllOf indicates all keys in this list must have signed attributes.
+     */
+    all_of: string[];
+    /**
+     * AnyOf means that at least of of the keys from the list must have signed attributes.
+     */
+    any_of: string[];
+}
+export interface SignedByAminoMsg {
+    type: "/akash.base.attributes.v1.SignedBy";
+    value: SignedByAmino;
+}
+/**
+ * PlacementRequirements represents the requirements for a provider placement on the network.
+ * It is used to specify the characteristics and constraints of a provider that can be used to satisfy a deployment request.
+ * @name PlacementRequirements
+ * @package akash.base.attributes.v1
+ * @see proto type: akash.base.attributes.v1.PlacementRequirements
+ */
+export interface PlacementRequirements {
+    /**
+     * SignedBy holds the list of keys that tenants expect to have signatures from.
+     */
+    signedBy: SignedBy;
+    /**
+     * Attribute holds the list of attributes tenant expects from the provider.
+     */
+    attributes: Attribute[];
+}
+export interface PlacementRequirementsProtoMsg {
+    typeUrl: "/akash.base.attributes.v1.PlacementRequirements";
+    value: Uint8Array;
+}
+/**
+ * PlacementRequirements represents the requirements for a provider placement on the network.
+ * It is used to specify the characteristics and constraints of a provider that can be used to satisfy a deployment request.
+ * @name PlacementRequirementsAmino
+ * @package akash.base.attributes.v1
+ * @see proto type: akash.base.attributes.v1.PlacementRequirements
+ */
+export interface PlacementRequirementsAmino {
+    /**
+     * SignedBy holds the list of keys that tenants expect to have signatures from.
+     */
+    signed_by: SignedByAmino;
+    /**
+     * Attribute holds the list of attributes tenant expects from the provider.
+     */
+    attributes: AttributeAmino[];
+}
+export interface PlacementRequirementsAminoMsg {
+    type: "/akash.base.attributes.v1.PlacementRequirements";
+    value: PlacementRequirementsAmino;
+}
+/**
+ * Attribute represents an arbitrary attribute key-value pair.
+ * @name Attribute
+ * @package akash.base.attributes.v1
+ * @see proto type: akash.base.attributes.v1.Attribute
+ */
+export declare const Attribute: {
+    typeUrl: string;
+    encode(message: Attribute, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): Attribute;
+    fromPartial(object: DeepPartial<Attribute>): Attribute;
+    fromAmino(object: AttributeAmino): Attribute;
+    toAmino(message: Attribute): AttributeAmino;
+    fromAminoMsg(object: AttributeAminoMsg): Attribute;
+    fromProtoMsg(message: AttributeProtoMsg): Attribute;
+    toProto(message: Attribute): Uint8Array;
+    toProtoMsg(message: Attribute): AttributeProtoMsg;
+};
+/**
+ * SignedBy represents validation accounts that tenant expects signatures for provider attributes.
+ * AllOf has precedence i.e. if there is at least one entry AnyOf is ignored regardless to how many
+ * entries there.
+ * @name SignedBy
+ * @package akash.base.attributes.v1
+ * @see proto type: akash.base.attributes.v1.SignedBy
+ */
+export declare const SignedBy: {
+    typeUrl: string;
+    encode(message: SignedBy, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): SignedBy;
+    fromPartial(object: DeepPartial<SignedBy>): SignedBy;
+    fromAmino(object: SignedByAmino): SignedBy;
+    toAmino(message: SignedBy): SignedByAmino;
+    fromAminoMsg(object: SignedByAminoMsg): SignedBy;
+    fromProtoMsg(message: SignedByProtoMsg): SignedBy;
+    toProto(message: SignedBy): Uint8Array;
+    toProtoMsg(message: SignedBy): SignedByProtoMsg;
+};
+/**
+ * PlacementRequirements represents the requirements for a provider placement on the network.
+ * It is used to specify the characteristics and constraints of a provider that can be used to satisfy a deployment request.
+ * @name PlacementRequirements
+ * @package akash.base.attributes.v1
+ * @see proto type: akash.base.attributes.v1.PlacementRequirements
+ */
+export declare const PlacementRequirements: {
+    typeUrl: string;
+    encode(message: PlacementRequirements, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): PlacementRequirements;
+    fromPartial(object: DeepPartial<PlacementRequirements>): PlacementRequirements;
+    fromAmino(object: PlacementRequirementsAmino): PlacementRequirements;
+    toAmino(message: PlacementRequirements): PlacementRequirementsAmino;
+    fromAminoMsg(object: PlacementRequirementsAminoMsg): PlacementRequirements;
+    fromProtoMsg(message: PlacementRequirementsProtoMsg): PlacementRequirements;
+    toProto(message: PlacementRequirements): Uint8Array;
+    toProtoMsg(message: PlacementRequirements): PlacementRequirementsProtoMsg;
+};

package/akash/base/attributes/v1/attribute.js

@@ -0,0 +1,260 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PlacementRequirements = exports.SignedBy = exports.Attribute = void 0;
+//@ts-nocheck
+const binary_1 = require("../../../../binary");
+function createBaseAttribute() {
+    return {
+        key: "",
+        value: ""
+    };
+}
+/**
+ * Attribute represents an arbitrary attribute key-value pair.
+ * @name Attribute
+ * @package akash.base.attributes.v1
+ * @see proto type: akash.base.attributes.v1.Attribute
+ */
+exports.Attribute = {
+    typeUrl: "/akash.base.attributes.v1.Attribute",
+    encode(message, writer = binary_1.BinaryWriter.create()) {
+        if (message.key !== "") {
+            writer.uint32(10).string(message.key);
+        }
+        if (message.value !== "") {
+            writer.uint32(18).string(message.value);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof binary_1.BinaryReader ? input : new binary_1.BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseAttribute();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.key = reader.string();
+                    break;
+                case 2:
+                    message.value = reader.string();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseAttribute();
+        message.key = object.key ?? "";
+        message.value = object.value ?? "";
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseAttribute();
+        if (object.key !== undefined && object.key !== null) {
+            message.key = object.key;
+        }
+        if (object.value !== undefined && object.value !== null) {
+            message.value = object.value;
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.key = message.key === "" ? undefined : message.key;
+        obj.value = message.value === "" ? undefined : message.value;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return exports.Attribute.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return exports.Attribute.decode(message.value);
+    },
+    toProto(message) {
+        return exports.Attribute.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/akash.base.attributes.v1.Attribute",
+            value: exports.Attribute.encode(message).finish()
+        };
+    }
+};
+function createBaseSignedBy() {
+    return {
+        allOf: [],
+        anyOf: []
+    };
+}
+/**
+ * SignedBy represents validation accounts that tenant expects signatures for provider attributes.
+ * AllOf has precedence i.e. if there is at least one entry AnyOf is ignored regardless to how many
+ * entries there.
+ * @name SignedBy
+ * @package akash.base.attributes.v1
+ * @see proto type: akash.base.attributes.v1.SignedBy
+ */
+exports.SignedBy = {
+    typeUrl: "/akash.base.attributes.v1.SignedBy",
+    encode(message, writer = binary_1.BinaryWriter.create()) {
+        for (const v of message.allOf) {
+            writer.uint32(10).string(v);
+        }
+        for (const v of message.anyOf) {
+            writer.uint32(18).string(v);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof binary_1.BinaryReader ? input : new binary_1.BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseSignedBy();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.allOf.push(reader.string());
+                    break;
+                case 2:
+                    message.anyOf.push(reader.string());
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseSignedBy();
+        message.allOf = object.allOf?.map(e => e) || [];
+        message.anyOf = object.anyOf?.map(e => e) || [];
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseSignedBy();
+        message.allOf = object.all_of?.map(e => e) || [];
+        message.anyOf = object.any_of?.map(e => e) || [];
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        if (message.allOf) {
+            obj.all_of = message.allOf.map(e => e);
+        }
+        else {
+            obj.all_of = message.allOf;
+        }
+        if (message.anyOf) {
+            obj.any_of = message.anyOf.map(e => e);
+        }
+        else {
+            obj.any_of = message.anyOf;
+        }
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return exports.SignedBy.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return exports.SignedBy.decode(message.value);
+    },
+    toProto(message) {
+        return exports.SignedBy.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/akash.base.attributes.v1.SignedBy",
+            value: exports.SignedBy.encode(message).finish()
+        };
+    }
+};
+function createBasePlacementRequirements() {
+    return {
+        signedBy: exports.SignedBy.fromPartial({}),
+        attributes: []
+    };
+}
+/**
+ * PlacementRequirements represents the requirements for a provider placement on the network.
+ * It is used to specify the characteristics and constraints of a provider that can be used to satisfy a deployment request.
+ * @name PlacementRequirements
+ * @package akash.base.attributes.v1
+ * @see proto type: akash.base.attributes.v1.PlacementRequirements
+ */
+exports.PlacementRequirements = {
+    typeUrl: "/akash.base.attributes.v1.PlacementRequirements",
+    encode(message, writer = binary_1.BinaryWriter.create()) {
+        if (message.signedBy !== undefined) {
+            exports.SignedBy.encode(message.signedBy, writer.uint32(10).fork()).ldelim();
+        }
+        for (const v of message.attributes) {
+            exports.Attribute.encode(v, writer.uint32(18).fork()).ldelim();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof binary_1.BinaryReader ? input : new binary_1.BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBasePlacementRequirements();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.signedBy = exports.SignedBy.decode(reader, reader.uint32());
+                    break;
+                case 2:
+                    message.attributes.push(exports.Attribute.decode(reader, reader.uint32()));
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBasePlacementRequirements();
+        message.signedBy = object.signedBy !== undefined && object.signedBy !== null ? exports.SignedBy.fromPartial(object.signedBy) : undefined;
+        message.attributes = object.attributes?.map(e => exports.Attribute.fromPartial(e)) || [];
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBasePlacementRequirements();
+        if (object.signed_by !== undefined && object.signed_by !== null) {
+            message.signedBy = exports.SignedBy.fromAmino(object.signed_by);
+        }
+        message.attributes = object.attributes?.map(e => exports.Attribute.fromAmino(e)) || [];
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.signed_by = message.signedBy ? exports.SignedBy.toAmino(message.signedBy) : exports.SignedBy.toAmino(exports.SignedBy.fromPartial({}));
+        if (message.attributes) {
+            obj.attributes = message.attributes.map(e => e ? exports.Attribute.toAmino(e) : undefined);
+        }
+        else {
+            obj.attributes = message.attributes;
+        }
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return exports.PlacementRequirements.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return exports.PlacementRequirements.decode(message.value);
+    },
+    toProto(message) {
+        return exports.PlacementRequirements.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/akash.base.attributes.v1.PlacementRequirements",
+            value: exports.PlacementRequirements.encode(message).finish()
+        };
+    }
+};

package/akash/base/resources/v1beta4/cpu.d.ts

@@ -0,0 +1,66 @@
+import { ResourceValue, ResourceValueAmino } from "./resourcevalue";
+import { Attribute, AttributeAmino } from "../../attributes/v1/attribute";
+import { BinaryReader, BinaryWriter } from "../../../../binary";
+import { DeepPartial } from "../../../../helpers";
+/**
+ * CPU stores resource units and cpu config attributes.
+ * @name CPU
+ * @package akash.base.resources.v1beta4
+ * @see proto type: akash.base.resources.v1beta4.CPU
+ */
+export interface CPU {
+    /**
+     * Units of the CPU, which represents the number of CPUs available.
+     * This field is required and must be a non-negative integer.
+     */
+    units: ResourceValue;
+    /**
+     * Attributes holds a list of key-value attributes that describe the GPU, such as its model, memory and interface.
+     * This field is required and must be a list of `Attribute` messages.
+     */
+    attributes: Attribute[];
+}
+export interface CPUProtoMsg {
+    typeUrl: "/akash.base.resources.v1beta4.CPU";
+    value: Uint8Array;
+}
+/**
+ * CPU stores resource units and cpu config attributes.
+ * @name CPUAmino
+ * @package akash.base.resources.v1beta4
+ * @see proto type: akash.base.resources.v1beta4.CPU
+ */
+export interface CPUAmino {
+    /**
+     * Units of the CPU, which represents the number of CPUs available.
+     * This field is required and must be a non-negative integer.
+     */
+    units?: ResourceValueAmino;
+    /**
+     * Attributes holds a list of key-value attributes that describe the GPU, such as its model, memory and interface.
+     * This field is required and must be a list of `Attribute` messages.
+     */
+    attributes?: AttributeAmino[];
+}
+export interface CPUAminoMsg {
+    type: "/akash.base.resources.v1beta4.CPU";
+    value: CPUAmino;
+}
+/**
+ * CPU stores resource units and cpu config attributes.
+ * @name CPU
+ * @package akash.base.resources.v1beta4
+ * @see proto type: akash.base.resources.v1beta4.CPU
+ */
+export declare const CPU: {
+    typeUrl: string;
+    encode(message: CPU, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): CPU;
+    fromPartial(object: DeepPartial<CPU>): CPU;
+    fromAmino(object: CPUAmino): CPU;
+    toAmino(message: CPU): CPUAmino;
+    fromAminoMsg(object: CPUAminoMsg): CPU;
+    fromProtoMsg(message: CPUProtoMsg): CPU;
+    toProto(message: CPU): Uint8Array;
+    toProtoMsg(message: CPU): CPUProtoMsg;
+};

package/akash/base/resources/v1beta4/cpu.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CPU = void 0;
+//@ts-nocheck
+const resourcevalue_1 = require("./resourcevalue");
+const attribute_1 = require("../../attributes/v1/attribute");
+const binary_1 = require("../../../../binary");
+function createBaseCPU() {
+    return {
+        units: resourcevalue_1.ResourceValue.fromPartial({}),
+        attributes: []
+    };
+}
+/**
+ * CPU stores resource units and cpu config attributes.
+ * @name CPU
+ * @package akash.base.resources.v1beta4
+ * @see proto type: akash.base.resources.v1beta4.CPU
+ */
+exports.CPU = {
+    typeUrl: "/akash.base.resources.v1beta4.CPU",
+    encode(message, writer = binary_1.BinaryWriter.create()) {
+        if (message.units !== undefined) {
+            resourcevalue_1.ResourceValue.encode(message.units, writer.uint32(10).fork()).ldelim();
+        }
+        for (const v of message.attributes) {
+            attribute_1.Attribute.encode(v, writer.uint32(18).fork()).ldelim();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof binary_1.BinaryReader ? input : new binary_1.BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseCPU();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.units = resourcevalue_1.ResourceValue.decode(reader, reader.uint32());
+                    break;
+                case 2:
+                    message.attributes.push(attribute_1.Attribute.decode(reader, reader.uint32()));
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseCPU();
+        message.units = object.units !== undefined && object.units !== null ? resourcevalue_1.ResourceValue.fromPartial(object.units) : undefined;
+        message.attributes = object.attributes?.map(e => attribute_1.Attribute.fromPartial(e)) || [];
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseCPU();
+        if (object.units !== undefined && object.units !== null) {
+            message.units = resourcevalue_1.ResourceValue.fromAmino(object.units);
+        }
+        message.attributes = object.attributes?.map(e => attribute_1.Attribute.fromAmino(e)) || [];
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.units = message.units ? resourcevalue_1.ResourceValue.toAmino(message.units) : undefined;
+        if (message.attributes) {
+            obj.attributes = message.attributes.map(e => e ? attribute_1.Attribute.toAmino(e) : undefined);
+        }
+        else {
+            obj.attributes = message.attributes;
+        }
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return exports.CPU.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return exports.CPU.decode(message.value);
+    },
+    toProto(message) {
+        return exports.CPU.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/akash.base.resources.v1beta4.CPU",
+            value: exports.CPU.encode(message).finish()
+        };
+    }
+};

package/akash/base/resources/v1beta4/endpoint.d.ts

@@ -0,0 +1,73 @@
+import { BinaryReader, BinaryWriter } from "../../../../binary";
+import { DeepPartial } from "../../../../helpers";
+/** Kind describes how the endpoint is implemented when the lease is deployed. */
+export declare enum Endpoint_Kind {
+    /** SHARED_HTTP - Describes an endpoint that becomes a Kubernetes Ingress. */
+    SHARED_HTTP = 0,
+    /** RANDOM_PORT - Describes an endpoint that becomes a Kubernetes NodePort. */
+    RANDOM_PORT = 1,
+    /** LEASED_IP - Describes an endpoint that becomes a leased IP. */
+    LEASED_IP = 2,
+    UNRECOGNIZED = -1
+}
+export declare const Endpoint_KindAmino: typeof Endpoint_Kind;
+export declare function endpoint_KindFromJSON(object: any): Endpoint_Kind;
+export declare function endpoint_KindToJSON(object: Endpoint_Kind): string;
+/**
+ * Endpoint describes a publicly accessible IP service.
+ * @name Endpoint
+ * @package akash.base.resources.v1beta4
+ * @see proto type: akash.base.resources.v1beta4.Endpoint
+ */
+export interface Endpoint {
+    /**
+     * Kind describes how the endpoint is implemented when the lease is deployed.
+     */
+    kind: Endpoint_Kind;
+    /**
+     * SequenceNumber represents a sequence number for the Endpoint.
+     */
+    sequenceNumber: number;
+}
+export interface EndpointProtoMsg {
+    typeUrl: "/akash.base.resources.v1beta4.Endpoint";
+    value: Uint8Array;
+}
+/**
+ * Endpoint describes a publicly accessible IP service.
+ * @name EndpointAmino
+ * @package akash.base.resources.v1beta4
+ * @see proto type: akash.base.resources.v1beta4.Endpoint
+ */
+export interface EndpointAmino {
+    /**
+     * Kind describes how the endpoint is implemented when the lease is deployed.
+     */
+    kind?: Endpoint_Kind;
+    /**
+     * SequenceNumber represents a sequence number for the Endpoint.
+     */
+    sequence_number: number;
+}
+export interface EndpointAminoMsg {
+    type: "/akash.base.resources.v1beta4.Endpoint";
+    value: EndpointAmino;
+}
+/**
+ * Endpoint describes a publicly accessible IP service.
+ * @name Endpoint
+ * @package akash.base.resources.v1beta4
+ * @see proto type: akash.base.resources.v1beta4.Endpoint
+ */
+export declare const Endpoint: {
+    typeUrl: string;
+    encode(message: Endpoint, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): Endpoint;
+    fromPartial(object: DeepPartial<Endpoint>): Endpoint;
+    fromAmino(object: EndpointAmino): Endpoint;
+    toAmino(message: Endpoint): EndpointAmino;
+    fromAminoMsg(object: EndpointAminoMsg): Endpoint;
+    fromProtoMsg(message: EndpointProtoMsg): Endpoint;
+    toProto(message: Endpoint): Uint8Array;
+    toProtoMsg(message: Endpoint): EndpointProtoMsg;
+};