typechain

const DEFAULT_FLAGS: CodegenConfig;

createBarrelFiles: (
    paths: string[],
    {
        typeOnly,
        postfix,
        moduleSuffix,
    }: { typeOnly: boolean; postfix?: string; moduleSuffix?: string }
) => FileDescription[];

detectInputsRoot: (allFiles: string[]) => string;

ensure0xPrefix: (hexString: string) => string;

ensureAbsPath: (path: string) => string;

extractAbi: (rawJson: string) => RawAbiDefinition[];

extractBytecode: (rawContents: string) => BytecodeWithLinkReferences | undefined;

extractDocumentation: (rawContents: string) => DocumentationResult | undefined;

getArgumentForSignature: (
    argument: EventArgDeclaration | AbiParameter
) => string;

getFileExtension: (path: string) => string;

getFilename: (path: string) => string;

getFullSignatureAsSymbolForEvent: (event: EventDeclaration) => string;

getFullSignatureForEvent: (event: EventDeclaration) => string;

getFunctionDocumentation: (
    abiPiece: RawAbiDefinition,
    documentation?: DocumentationResult
) => FunctionDocumentation | undefined;

getIndexedSignatureForEvent: (event: EventDeclaration) => string;

getSignatureForFn: (fn: FunctionDeclaration) => string;

glob: (
    cwd: string,
    patternsOrFiles: string[],
    ignoreNodeModules?: boolean
) => string[];

isConstant: (fn: FunctionDeclaration) => boolean;

isConstantFn: (fn: FunctionDeclaration) => boolean;

lowestCommonPath: (paths: string[]) => string;

normalizeName: (rawName: string) => string;

normalizeSlashes: (path: string) => string;

parse: (
    abi: RawAbiDefinition[],
    path: string,
    documentation?: DocumentationResult
) => Contract;

parseContractPath: (path: string) => {
    name: string;
    rawName: string;
    path: string[];
};

parseEvent: (
    abiPiece: RawEventAbiDefinition,
    registerStruct: (struct: StructType) => void
) => EventDeclaration;

parseEvmType: (
    rawType: string,
    components?: EvmSymbol[],
    internalType?: string
) => EvmType;

runTypeChain: (
    publicConfig: MarkOptional<Config, 'flags' | 'inputDir'>
) => Promise<Result>;

shortenFullJsonFilePath: (path: string, allPaths: string[]) => string;

type AddressType = {
    type: 'address';
    originalType: string;
};

type ArrayType = {
    type: 'array';
    itemType: EvmType;
    size?: number;
    originalType: string;
    structName?: StructName;
};

type BooleanType = {
    type: 'boolean';
    originalType: string;
};

type BytesType = {
    type: 'bytes';
    size: number;
    originalType: string;
};

type DynamicBytesType = {
    type: 'dynamic-bytes';
    originalType: string;
};

type EvmOutputType = EvmType | VoidType;

type EvmSymbol = {
    type: EvmType;
    name: string;
};

type EvmType =
    | BooleanType
    | IntegerType
    | UnsignedIntegerType
    | StringType
    | BytesType
    | DynamicBytesType
    | AddressType
    | ArrayType
    | TupleType
    | UnknownType;

type IntegerType = {
    type: 'integer';
    bits: number;
    originalType: string;
};

type Named<T> = {
    name: string;
    values: T;
};

type Output = void | FileDescription | FileDescription[];

type PublicConfig = MarkOptional<Config, 'flags' | 'inputDir'>;

type StateMutability = 'pure' | 'view' | 'nonpayable' | 'payable';

type StringType = {
    type: 'string';
    originalType: string;
};

type StructType = ArrayType | TupleType;

type TupleType = {
    type: 'tuple';
    components: EvmSymbol[];
    originalType: string;
    structName?: StructName;
};

type UnknownType = {
    type: 'unknown';
    originalType: string;
};

type UnsignedIntegerType = {
    type: 'uinteger';
    bits: number;
    originalType: string;
};

type VoidType = {
    type: 'void';
};