import type { Directory, Project } from 'ts-morph';
import type { PluginProps } from '@stackpress/idea-transformer/types';
import type { SchemaConfig, Data } from '@stackpress/idea-parser';
export type { EnumConfig, ModelConfig, TypeConfig, PropConfig, PluginConfig, SchemaConfig } from '@stackpress/idea-parser/types';
import type Terminal from 'stackpress-server/Terminal';
import type DefinitionInterface from './interface/DefinitionInterface.js';
import type SchemaInterface from './interface/SchemaInterface.js';
export type AttributeData<D extends Record<string, unknown> = Record<string, unknown>> = {
    type: Array<string>;
    name: string;
    description?: string;
    args: Array<{
        spread: boolean;
        type: Array<string | Record<string, unknown>>;
        name?: string;
        required: boolean;
        description: string;
        examples: Array<unknown>;
    }>;
    data?: D;
};
export type AttributeDataMap<D extends Record<string, unknown> = Record<string, unknown>> = Record<string, Required<AttributeData<D>>>;
export type AttributeDataComponent = {
    name: string;
    import: {
        from: string;
        default: boolean;
    };
    attributes: Record<string, unknown>;
};
export type AttributeDataAssertion = {
    name: string;
    message: string;
};
export type TypeAssertionMap = Record<string, AttributeDataAssertion>;
export type DefinitionBook = Map<string, Record<string, unknown>>;
export type AttributeDefinitionInput = {
    method: boolean;
    flag: boolean;
    description: string;
    args: Array<{
        spread: boolean;
        type: Array<string | Record<string, unknown>>;
        required: boolean;
        description: string;
        examples: Array<unknown>;
    }>;
};
export type AttributeDefinitionToken = AttributeDefinitionInput & {
    kind: string;
};
export type AttributeComponentInput = AttributeDataComponent & {
    props: Record<string, {
        type: string[];
        required: boolean;
        description: string;
        examples: unknown[];
    }>;
};
export type AttributeComponentToken = AttributeComponentInput & {
    kind: string;
};
export type AttributeAssertionInput = AttributeDataAssertion;
export type AttributeAssertionToken = AttributeAssertionInput;
export type AttributeMapToken = Record<string, Data[] | boolean>;
export type AttributesEntriesToken = Array<[string, Data[] | boolean]>;
export type AttributesToken = AttributesEntriesToken | AttributeMapToken;
export type ColumnTypeToken = {
    name: string;
    required: boolean;
    multiple: boolean;
};
export type ColumnToken = {
    name: string;
    type: ColumnTypeToken;
    attributes?: AttributesToken;
};
export type ColumnAssertionToken = AttributeAssertionToken & {
    args: unknown[];
};
export type ColumnRelationProps = {
    local: string;
    foreign: string;
    name?: string;
};
export type IsArrayOrObject<T> = T extends any[] ? true : T extends object ? (T extends Function ? false : true) : false;
export type DefinitionInterfaceMap = {
    [key: string]: DefinitionInterface;
};
export type AssertInterfaceMap<C extends DefinitionInterfaceMap> = {
    [K in keyof C]: C[K] extends DefinitionInterface<unknown, infer A> ? A : unknown;
};
export type SerializeInterfaceMap<C extends DefinitionInterfaceMap> = {
    [K in keyof C]: C[K] extends DefinitionInterface<unknown, unknown, infer S> ? (IsArrayOrObject<S> extends true ? string : S) : unknown;
};
export type UnserializeInterfaceMap<C extends DefinitionInterfaceMap> = {
    [K in keyof C]: C[K] extends DefinitionInterface<unknown, unknown, unknown, infer U> ? U : unknown;
};
export type ErrorReport = string | ErrorReport[] | {
    [key: string]: ErrorReport;
};
export type ClientProjectProps = {
    terminal: Terminal;
    project: Project;
    directory: Directory;
};
export type ClientPluginProps = PluginProps<ClientProjectProps>;
export type ClientFieldset<T extends Record<string, unknown> = Record<string, unknown>, C extends DefinitionInterfaceMap = DefinitionInterfaceMap> = {
    Schema: {
        new (seed?: string): SchemaInterface<T, C>;
    };
    columns: C;
};
export type Client<F extends Record<string, ClientFieldset> = Record<string, ClientFieldset>> = {
    config: SchemaConfig;
    model: F;
    fieldset: F;
};
export type ClientPlugin<F extends Record<string, ClientFieldset> = Record<string, ClientFieldset>> = (nullable?: boolean) => Promise<Client<F>>;
export type ClientConfig = {
    build?: string;
    lang?: string;
    module: string;
    package: string;
    revisions?: string;
    tsconfig: string;
    prettier?: {
        semi?: boolean;
        singleQuote?: boolean;
        jsxSingleQuote?: boolean;
        trailingComma?: 'none' | 'es5' | 'all';
        bracketSpacing?: boolean;
        objectWrap?: 'preserve' | 'collapse';
        bracketSameLine?: boolean;
        requirePragma?: boolean;
        insertPragma?: boolean;
        checkIgnorePragma?: boolean;
        proseWrap?: 'always' | 'never' | 'preserve';
        arrowParens?: 'avoid' | 'always';
        htmlWhitespaceSensitivity?: 'css' | 'strict' | 'ignore';
        endOfLine?: 'auto' | 'lf' | 'crlf' | 'cr';
        quoteProps?: 'as-needed' | 'consistent' | 'preserve';
        embeddedLanguageFormatting?: 'auto' | 'off';
        singleAttributePerLine?: boolean;
        experimentalOperatorPosition?: 'start' | 'end';
        experimentalTernaries?: boolean;
        jsxBracketSameLine?: boolean;
    };
};