react-styleguidist

description?: string;

exampleMode?: ExpandMode;

filepath?: string;

hasExamples?: boolean;

href?: string;

name?: string;

pathLine?: string;

slug?: string;

usageMode?: ExpandMode;

description?: string;

exampleMode?: ExpandMode;

expand?: boolean;

external?: boolean;

href?: string;

ignore?: string | string[];

name?: string;

sectionDepth?: number;

slug?: string;

usageMode?: ExpandMode;

content: string;

lang?: string | null;

settings?: Record<string, any>;

type: 'code';

metadata?: {
    tags?: string[];
};

module?: number;

props?: {
    displayName?: string;
    visibleName?: string;
    description?: string;
    methods?: MethodDescriptor[];
    props?: PropDescriptor[];
    tags?: TagProps;
    example?: Example[];
    examples?: Example[];
};

visibleName?: string;

components?: string | string[] | (() => string[]);

content?: string;

sections?: ConfigSection[];

metadata: RequireItResult | Record<string, unknown>;

module: RequireItResult;

props: RequireItResult;

components: LoaderComponent[];

content?: RequireItResult | MarkdownExample;

sections: LoaderSection[];

slug?: string;

content: string;

settings?: Record<string, any>;

type: 'markdown';

docblock: string;

externalLink?: boolean;

filepath?: string;

href?: string;

visibleName?: string;

sections: Section[];

styles: ((th: Theme) => Styles) | Styles;

theme: RecursivePartial<Theme>;

examples?: RequireItResult | null;

props?: Record<string, PropDescriptor> | PropDescriptor[];

require: string;

toAST: () => ASTNode;

evalInContext: (a: string) => () => any;

sections: ConfigSection[];

components?: Component[];

content?: Example[] | string;

sections?: Section[];

defaultExample?: string | boolean;

displayName: string;

doclets: Record<string, any>;

example?: RequireItResult | null;

methods?: MethodWithDocblock[];

visibleName?: string;

borderRadius: number;

buttonTextTransform: string;

color: {
    base: string;
    light: string;
    lightest: string;
    link: string;
    linkHover: string;
    focus: string;
    border: string;
    name: string;
    type: string;
    error: string;
    baseBackground: string;
    codeBackground: string;
    sidebarBackground: string;
    ribbonBackground: string;
    ribbonText: string;
    codeBase: string;
    codeComment: string;
    codePunctuation: string;
    codeProperty: string;
    codeDeleted: string;
    codeString: string;
    codeInserted: string;
    codeOperator: string;
    codeKeyword: string;
    codeFunction: string;
    codeVariable: string;
};

fontFamily: {
    base: string[];
    monospace: string[];
};

fontSize: {
    base: number;
    text: number;
    small: number;
    h1: number;
    h2: number;
    h3: number;
    h4: number;
    h5: number;
    h6: number;
};

maxWidth: number;

mq: {
    small: string;
};

sidebarWidth: number;

space: number[];

spaceFactor: number;

components?: TOCItem[];

content?: React.ReactNode;

forcedOpen?: boolean;

heading?: boolean;

initialOpen?: boolean;

sections?: TOCItem[];

selected?: boolean;

shouldOpenInNewTab?: boolean;

template: (...args: any[]) => string;

acornJsx: () => (BaseParser: any) => any;

commonDir: (list: string[]) => string;

deabsdeep: <T>(objectToFreze: T, opt?: Options) => T;

deepfreeze: <T>(objectToFreze: T) => T;

const findup: { sync(cwd: string, path: string): string };

getLogger: (namespace: string) => GloggLogger;

listify: (list: any[], opt?: ListifyOptions) => string;

stringify: (obj: any) => string;

const defaultHandlers: Handler[];

const resolver: {
    findAllComponentDefinitions(ast: ASTNode): NodePath[];
    findAllExportedComponentDefinitions(
        ast: ASTNode,
        recast: {
            visit: (
                path: NodePath,
                handlers: { [handlerName: string]: () => boolean | undefined }
            ) => void;
        }
    ): NodePath[];
    findExportedComponentDefinition(ast: ASTNode): NodePath | undefined;
};

const utils: { docblock: { getDoclets: (str?: string) => Record<string, any> } };

parse: (
    source: string | Buffer,
    resolver?: (
        ast: ASTNode,
        parser: { parse: (code: string) => ASTNode }
    ) => NodePath<any, any> | NodePath[],
    handlers?: Handler[],
    options?: Options
) => DocumentationObject | DocumentationObject[];

type Handler = (documentation: Documentation, path: NodePath) => void;

annotationResolver: (
    ast: AnnoASTNode,
    recast: {
        visit: (
            node: AnnoNodePath,
            handlers: { [handlerName: string]: () => boolean | undefined }
        ) => void;
    }
) => AnnoNodePath[];

createDisplayNameHandler: (componentPath: string) => Handler;

type Handler = (
    documentation: Documentation,
    path: DisplaNameHandlerNodePath
) => void;

stripHtmlComments: (text: string) => string;

stripShebang: (input: string) => string;

toAST: (obj: any) => ASTNode;

const webpackMerge: {
    (options: WebpackMergeOptions): mergeFunction;
    (...configs: MetaConfig[]): Configuration;
    unique(
        key: string,
        uniques: string[],
        getter?: (plugin: WebpackPluginInstance) => string | undefined | false
    ): customizeArrayFuntion;
};