@slippy-lint/slippy/dist/rules/naming-convention.d.ts

A simple but powerful linter for Solidity

import { RuleDefinition } from "./types.js";
import * as z from "zod";
declare enum PredefinedFormats {
    camelCase = 1,
    strictCamelCase = 2,
    PascalCase = 3,
    StrictPascalCase = 4,
    snake_case = 5,
    UPPER_CASE = 6
}
declare enum UnderscoreOptions {
    forbid = 1,
    allow = 2,
    require = 3,
    requireDouble = 4,
    allowDouble = 5,
    allowSingleOrDouble = 6
}
export declare enum Selectors {
    contract = 1,
    interface = 2,
    library = 4,
    stateVariable = 8,
    function = 16,
    variable = 32,
    struct = 64,
    structMember = 128,
    enum = 256,
    enumMember = 512,
    parameter = 1024,
    modifier = 2048,
    event = 4096,
    eventParameter = 8192,
    userDefinedValueType = 16384,
    error = 32768,
    errorParameter = 65536,
    mappingParameter = 131072
}
export declare enum MetaSelectors {
    default = -1,
    typeLike = 53575,
    variableLike = 208056
}
declare enum Modifiers {
    constant = 1,
    immutable = 2,
    public = 4,
    internal = 8,
    private = 16,
    external = 32,
    view = 64,
    pure = 128,
    payable = 256,
    virtual = 512,
    override = 1024,
    abstract = 2048,
    noParameters = 4096,
    hasParameters = 8192,
    contract = 16384,
    interface = 32768,
    library = 65536
}
interface NormalizedMatchRegex {
    match: boolean;
    regex: RegExp;
}
interface NormalizedSelector {
    custom: NormalizedMatchRegex | null;
    filter: NormalizedMatchRegex | null;
    format: PredefinedFormats[] | null;
    leadingUnderscore: UnderscoreOptions | null;
    modifiers: Modifiers[] | null;
    modifierWeight: number;
    selector: MetaSelectors | Selectors;
    trailingUnderscore: UnderscoreOptions | null;
}
type NamingConventionNormalizedConfig = NormalizedSelector[];
export declare function normalizeConfig(userConfig: Config): NamingConventionNormalizedConfig;
export declare const Schema: z.ZodDefault<z.ZodArray<z.ZodObject<{
    custom: z.ZodOptional<z.ZodObject<{
        match: z.ZodBoolean;
        regex: z.ZodString;
    }, z.core.$strip>>;
    filter: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
        match: z.ZodBoolean;
        regex: z.ZodString;
    }, z.core.$strip>]>>;
    format: z.ZodNullable<z.ZodArray<z.ZodEnum<{
        camelCase: "camelCase";
        strictCamelCase: "strictCamelCase";
        PascalCase: "PascalCase";
        StrictPascalCase: "StrictPascalCase";
        snake_case: "snake_case";
        UPPER_CASE: "UPPER_CASE";
    }>>>;
    leadingUnderscore: z.ZodOptional<z.ZodEnum<{
        forbid: "forbid";
        allow: "allow";
        require: "require";
        requireDouble: "requireDouble";
        allowDouble: "allowDouble";
        allowSingleOrDouble: "allowSingleOrDouble";
    }>>;
    modifiers: z.ZodOptional<z.ZodArray<z.ZodEnum<{
        virtual: "virtual";
        override: "override";
        contract: "contract";
        interface: "interface";
        library: "library";
        constant: "constant";
        immutable: "immutable";
        public: "public";
        internal: "internal";
        private: "private";
        external: "external";
        view: "view";
        pure: "pure";
        payable: "payable";
        abstract: "abstract";
        noParameters: "noParameters";
        hasParameters: "hasParameters";
    }>>>;
    selector: z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodEnum<{
        function: "function";
        error: "error";
        enum: "enum";
        contract: "contract";
        interface: "interface";
        library: "library";
        stateVariable: "stateVariable";
        variable: "variable";
        struct: "struct";
        structMember: "structMember";
        enumMember: "enumMember";
        parameter: "parameter";
        modifier: "modifier";
        event: "event";
        eventParameter: "eventParameter";
        userDefinedValueType: "userDefinedValueType";
        errorParameter: "errorParameter";
        mappingParameter: "mappingParameter";
    }>, z.ZodEnum<{
        default: "default";
        typeLike: "typeLike";
        variableLike: "variableLike";
    }>]>, z.ZodArray<z.ZodUnion<readonly [z.ZodEnum<{
        function: "function";
        error: "error";
        enum: "enum";
        contract: "contract";
        interface: "interface";
        library: "library";
        stateVariable: "stateVariable";
        variable: "variable";
        struct: "struct";
        structMember: "structMember";
        enumMember: "enumMember";
        parameter: "parameter";
        modifier: "modifier";
        event: "event";
        eventParameter: "eventParameter";
        userDefinedValueType: "userDefinedValueType";
        errorParameter: "errorParameter";
        mappingParameter: "mappingParameter";
    }>, z.ZodEnum<{
        default: "default";
        typeLike: "typeLike";
        variableLike: "variableLike";
    }>]>>]>;
    trailingUnderscore: z.ZodOptional<z.ZodEnum<{
        forbid: "forbid";
        allow: "allow";
        require: "require";
        requireDouble: "requireDouble";
        allowDouble: "allowDouble";
        allowSingleOrDouble: "allowSingleOrDouble";
    }>>;
}, z.core.$strip>>>;
type Config = z.infer<typeof Schema>;
export declare const NamingConvention: RuleDefinition<Config>;
export {};