import { MessageType } from "@protobuf-ts/runtime";
export interface Package {
    storageId?: string;
    originalId?: string;
    version?: bigint;
    modules: Module[];
    typeOrigins: TypeOrigin[];
    linkage: Linkage[];
}
export interface Module {
    name?: string;
    contents?: Uint8Array;
    datatypes: DatatypeDescriptor[];
    functions: FunctionDescriptor[];
}
export interface DatatypeDescriptor {
    typeName?: string;
    definingId?: string;
    module?: string;
    name?: string;
    abilities: Ability[];
    typeParameters: TypeParameter[];
    kind?: DatatypeDescriptor_DatatypeKind;
    fields: FieldDescriptor[];
    variants: VariantDescriptor[];
}
export declare enum DatatypeDescriptor_DatatypeKind {
    DATATYPE_KIND_UNKNOWN = 0,
    STRUCT = 1,
    ENUM = 2
}
export interface TypeParameter {
    constraints: Ability[];
    isPhantom?: boolean;
}
export interface FieldDescriptor {
    name?: string;
    position?: number;
    type?: OpenSignatureBody;
}
export interface VariantDescriptor {
    name?: string;
    position?: number;
    fields: FieldDescriptor[];
}
export interface OpenSignatureBody {
    type?: OpenSignatureBody_Type;
    typeName?: string;
    typeParameterInstantiation: OpenSignatureBody[];
    typeParameter?: number;
}
export declare enum OpenSignatureBody_Type {
    TYPE_UNKNOWN = 0,
    ADDRESS = 1,
    BOOL = 2,
    U8 = 3,
    U16 = 4,
    U32 = 5,
    U64 = 6,
    U128 = 7,
    U256 = 8,
    VECTOR = 9,
    DATATYPE = 10,
    TYPE_PARAMETER = 11
}
export interface FunctionDescriptor {
    name?: string;
    visibility?: FunctionDescriptor_Visibility;
    isEntry?: boolean;
    typeParameters: TypeParameter[];
    parameters: OpenSignature[];
    returns: OpenSignature[];
}
export declare enum FunctionDescriptor_Visibility {
    VISIBILITY_UNKNOWN = 0,
    PRIVATE = 1,
    PUBLIC = 2,
    FRIEND = 3
}
export interface OpenSignature {
    reference?: OpenSignature_Reference;
    body?: OpenSignatureBody;
}
export declare enum OpenSignature_Reference {
    REFERENCE_UNKNOWN = 0,
    IMMUTABLE = 1,
    MUTABLE = 2
}
export interface TypeOrigin {
    moduleName?: string;
    datatypeName?: string;
    packageId?: string;
}
export interface Linkage {
    originalId?: string;
    upgradedId?: string;
    upgradedVersion?: bigint;
}
export declare enum Ability {
    ABILITY_UNKNOWN = 0,
    COPY = 1,
    DROP = 2,
    STORE = 3,
    KEY = 4
}
declare class Package$Type extends MessageType<Package> {
    constructor();
}
export declare const Package: Package$Type;
declare class Module$Type extends MessageType<Module> {
    constructor();
}
export declare const Module: Module$Type;
declare class DatatypeDescriptor$Type extends MessageType<DatatypeDescriptor> {
    constructor();
}
export declare const DatatypeDescriptor: DatatypeDescriptor$Type;
declare class TypeParameter$Type extends MessageType<TypeParameter> {
    constructor();
}
export declare const TypeParameter: TypeParameter$Type;
declare class FieldDescriptor$Type extends MessageType<FieldDescriptor> {
    constructor();
}
export declare const FieldDescriptor: FieldDescriptor$Type;
declare class VariantDescriptor$Type extends MessageType<VariantDescriptor> {
    constructor();
}
export declare const VariantDescriptor: VariantDescriptor$Type;
declare class OpenSignatureBody$Type extends MessageType<OpenSignatureBody> {
    constructor();
}
export declare const OpenSignatureBody: OpenSignatureBody$Type;
declare class FunctionDescriptor$Type extends MessageType<FunctionDescriptor> {
    constructor();
}
export declare const FunctionDescriptor: FunctionDescriptor$Type;
declare class OpenSignature$Type extends MessageType<OpenSignature> {
    constructor();
}
export declare const OpenSignature: OpenSignature$Type;
declare class TypeOrigin$Type extends MessageType<TypeOrigin> {
    constructor();
}
export declare const TypeOrigin: TypeOrigin$Type;
declare class Linkage$Type extends MessageType<Linkage> {
    constructor();
}
export declare const Linkage: Linkage$Type;
export {};