import type * as core from '@contentlayer2/core';
import type { Thunk } from '@contentlayer2/utils';
import type { ComputedField } from './computed-field.js';
import type { FieldDef, FieldDefWithName } from './field.js';
export * from './field.js';
export type SchemaDef = {
    documentTypeDefs: DocumentTypeDef[];
};
export type DocumentContentType = 'markdown' | 'mdx' | 'data';
export type TypeExtensions<DefName extends string = string> = {
    stackbit?: core.StackbitExtension.TypeExtension<DefName>;
};
export type FieldDefs = Record<string, FieldDef> | FieldDefWithName[];
export type DocumentTypeDef<DefName extends string = string> = {
    name: DefName;
    description?: string;
    /**
     * The field definitions can either be provided as an object with the field names as keys or
     * as an array of all field definitions including the name as an extra field. (The array definition
     * can be used if you want more control over the order of the fields.)
     *
     * @default []
     */
    fields?: FieldDefs;
    computedFields?: ComputedFields<DefName>;
    /** Path is relative to the `contentDirPath` config */
    filePathPattern?: string;
    /**
     * Default is `markdown`
     *
     * Choose `data` e.g. for a `.json` or `.yaml` file
     */
    contentType?: DocumentContentType;
    isSingleton?: boolean;
    extensions?: TypeExtensions<DefName>;
};
export type ComputedFields<DefName extends string = string> = Record<string, ComputedField<DefName>>;
export type NestedTypeDef<DefName extends string = string> = {
    name: DefName;
    description?: string;
    /** @default [] */
    fields?: FieldDefs;
    extensions?: TypeExtensions<DefName>;
};
export declare const isNestedTypeDef: (_: NestedTypeDef | NestedUnnamedTypeDef) => _ is NestedTypeDef;
export type NestedUnnamedTypeDef = {
    /** @default [] */
    fields?: FieldDefs;
    extensions?: TypeExtensions;
};
export declare const isNestedUnnamedTypeDef: (_: NestedTypeDef | NestedUnnamedTypeDef) => _ is NestedUnnamedTypeDef;
export type NestedType<DefName extends string = string> = {
    type: 'nested';
    def: Thunk<NestedTypeDef<DefName> | NestedUnnamedTypeDef>;
};
export type DocumentType<DefName extends string = string> = {
    type: 'document';
    def: Thunk<DocumentTypeDef<DefName>>;
};
export type DocumentTypes = DocumentType<any>[] | Record<string, DocumentType<any>>;
export declare const defineNestedType: <DefName extends string>(def: Thunk<NestedTypeDef<DefName> | NestedUnnamedTypeDef>) => NestedType;
export declare const defineDocumentType: <DefName extends string>(def: Thunk<DocumentTypeDef<DefName>>) => DocumentType;
export declare const defineFields: <TFieldDefs extends FieldDefs>(fields: TFieldDefs) => TFieldDefs;
export declare const defineComputedFields: <TDefName extends string, TComputedFields extends ComputedFields<TDefName> = ComputedFields<TDefName>>(computedFields: TComputedFields) => TComputedFields;
//# sourceMappingURL=index.d.ts.map