alinea

export function BrowserPreview(

props: BrowserPreviewProps

): Element

/**

Create a check field configuration */

export function check(

label: Label,

options: CheckOptions

): CheckField

export function code(

label: Label,

options: CodeFieldOptions

): CodeField

export type Collection<T>

= CollectionImpl<T> & Fields<T>

export const Collection: CollectionConstructor

/**

Configuration options for the dashboard */

export class Config<T extends Workspaces = Workspaces>

{

constructor<T extends Workspaces = Workspaces>(

options: ConfigOptions<T>

): Config<T>

options: ConfigOptions<T>

workspaces:

/**

Get the first workspace */

get defaultWorkspace(): Workspace<any>

/**

Get a root */

root(

workspace: string,

root: string

): Root<string>

/**

Find a type by workspace and name */

type(

workspace: string,

): undefined | Type<any>

}

/**

Create a new config instance */

export function createConfig<T extends Workspaces>(

options: ConfigOptions<T>

): Config<T>

export type Cursor<T>

= CursorImpl<T> & Fields<T>

export const Cursor: CursorConstructor

export class Expr<T>

{

constructor<T>(

expr: ExprData

): Expr<T>

expr: ExprData

NULL: ExprData

uniqueId: number

__id(): string

add(

this: Expr<number>,

that: EV<number>

): Expr<number>

and(

this: Expr<boolean>,

that: EV<boolean>

): Expr<boolean>

asc(): OrderBy

at(

this: Expr<Array<T>>,

index: number

): Expr<null | T>

case<T extends string | number, C extends , DC extends SelectionInput>(

this: Expr<T>,

cases: C,

defaultCase: DC

): Expr<TypeOf<C[keyof C]> | TypeOf<DC>>

concat(

this: Expr<string>,

that: EV<string>

): Expr<string>

desc(): OrderBy

divide(

this: Expr<number>,

that: EV<number>

): Expr<number>

each<T>(

this: Expr<Array<T>>

): Cursor<T>

get<K extends string | number | symbol>(

): Expr<T[K]>

glob(

this: Expr<string>,

that: EV<string>

): Expr<boolean>

greater(

that: any

): Expr<boolean>

greaterOrEqual(

that: any

): Expr<boolean>

is(

that: EV<T> | CursorSingleRow<T>

): Expr<boolean>

isIn<T>(

this: Expr<T>,

that: EV<Array<T>> | Cursor<T>

): Expr<boolean>

isNot(

that: EV<T>

): Expr<boolean>

isNotIn<T>(

this: Expr<T>,

that: EV<Array<T>> | Cursor<T>

): Expr<boolean>

isNotNull(): Expr<boolean>

isNull(): Expr<boolean>

less(

that: any

): Expr<boolean>

lessOrEqual(

that: any

): Expr<boolean>

like(

this: Expr<string>,

that: EV<string>

): Expr<boolean>

map<T, X extends SelectionInput>(

this: Expr<Array<T>>,

fn: {}

): Selection<Array<TypeOf<X>>>

match(

this: Expr<string>,

that: EV<string>

): Expr<boolean>

multiply(

this: Expr<number>,

that: EV<number>

): Expr<number>

not(): Expr<boolean>

or(

this: Expr<boolean>,

that: EV<boolean>

): Expr<boolean>

remainder(

this: Expr<number>,

that: EV<number>

): Expr<number>

substract(

this: Expr<number>,

that: EV<number>

): Expr<number>

sure(): Expr<NonNullable<T>>

with<Row extends {}, X extends SelectionInput>(

this: Expr<Row>,

that: X

): With<Row, X>

create<T>(

input: EV<T>

): Expr<T>

value<T>(

value: T

): Expr<T>

}

/**

Create a link field configuration */

export function link<T = {}, Q = (Entry & T) & (Url & T)>(

label: Label,

options: LinkOptions<T, Q>

): LinkField<T, Q>

/**

Create a list field configuration */

export function list<T, Q = Array<T & ListRow>>(

label: Label,

options: ListOptions<T, Q>

): ListField<T, Q>

export const MediaSchema:

{

File: TypeConfig<

{

title: string

}

MediaLibrary: TypeConfig<

{

title: string

}

export function number(

label: Label,

options: NumberOptions

): NumberField

export function object<T>(

label: Label,

options: ObjectOptions<T>

): ObjectField<T>

export function path(

label: Label,

options: PathOptions

): PathField

/**

Create a rich text field configuration */

export function richText<T, Q = TextDoc<T>>(

label: Label,

options: RichTextOptions<T, Q>

): RichTextField<T, Q>

export function root<T>(

label: Label,

options: RootOptions<T>

): RootConfig<T>

export class Root<T = string>

{

constructor<T = string>(

workspace: string,

config: RootConfig<T>

): Root<T>

label: Label

workspace: string

get contains(): Array<T>

get defaultLocale(): undefined | string

get i18n(): undefined | {locales: Array<string>}

get icon(): undefined | ComponentType<{}>

}

/**

Create a schema, expects a string record of Type instances */

export function schema<Types extends LazyRecord<TypeConfig<any>>>(

types: Types

): SchemaConfig<TypeToEntry<TypeToRows<Types>>>

export namespace Schema {

/**

Utility to infer the type of a Schema, Type, Feld or any Store type */

export type TypeOf<T>

= T extends Schema<infer U>

? U

: T extends Type<infer U>

? U

: T extends TypeConfig<infer U>

? U

: T extends Field<infer U, infer M, infer Q>

? Q

: T extends Selection<infer U>

? U

: T extends Cursor<infer U>

? U

: never

}

/**

Describes the different types of entries */

export class Schema<T = any> extends SchemaConfig<T>

{

constructor<T = any>(

workspace: Workspace<T>,

config: SchemaConfig<T>

): Schema<T>

shape: Record<string, RecordShape<any>>

typeMap: Map<string, Type<any>>

types: LazyRecord<TypeConfig<any>>

workspace: Workspace<T>

/**

Keys of every type */

get keys(): Array<string>

[iterator](): IterableIterator<[string, Type<any>]>

/**

A generic collection used to query any type in this schema */

collection(): Collection<T>

concat<X>(

that: SchemaConfig<X>

): SchemaConfig<T | X>

configEntries(): Array<[string, TypeConfig<any>]>

entries(): IterableIterator<[string, Type<any>]>

toSchema(

workspace: Workspace<T>

): Schema<T>

/**

Get a type by name */

type<K extends string>(

): undefined | Type<Extract<T, {type: K}>>

type(

): undefined | Type<any>

}

/**

Create a select field configuration */

export function select(

label: Label,

items: SelectItems,

options: SelectOptions

): SelectField

/**

Create a tab configuration */

export function tab<T extends Array<Input<any>>>(

label: Label,

sections: T

): TypeConfig<Section.FieldsOf<T[number]>>

/**

Create tabs configuration */

export function tabs<T extends Array<TypeConfig<any>>>(

types: T

): Section<UnionToIntersection<Type.Of<T[number]>>>

/**

Create a text field configuration */

export function text(

label: Label,

options: TextOptions

): TextField

export type TextDoc<T>

= Array<TextNode<T>>

export namespace Tree {

export function children(

id: EV<string>,

depth: number

): Cursor<Entry>

export function nextSibling(

id: EV<string>

): CursorSingleRow<Entry>

export function parent(

id: EV<string>

): Cursor<Entry>

export function parents(

id: EV<string>

): Cursor<Entry>

export function prevSibling(

id: EV<string>

): CursorSingleRow<Entry>

export function siblings(

id: EV<string>

): Cursor<Entry>

}

/**

Create a new type */

export function type<T extends Array<Input<any>>>(

label: Label,

sections: T

): TypeConfig<Section.FieldsOf<T[number]>>

export namespace Type {

/**

Infer the field types */

export type Of<T>

= T extends TypeConfig<infer U>

? U

: never

}

/**

Describes the structure of an entry by their fields and type */

export class Type<T = any> extends TypeConfig<T>

{

constructor<T = any>(

schema: Schema<any>,

config: TypeConfig<T>

): Type<T>

fields: Record<string, Field<any, any, any>>

label: Label

options: TypeOptions<T>

schema: Schema<any>

sections: Array<Section<any>>

shape: RecordShape<T>

get isContainer(): boolean

[iterator](): IterableIterator<[string, Field<any, any, any>]>

collection(): Collection<T>

configure(

options: TypeOptions<T>

): TypeConfig<T>

/**

Create a new Entry instance of this type */

create(): Entry & T

/**

Create a new empty instance of this type's fields */

empty(): T

/**

Get a field by name */

field(

key: string

): Field<any, any, any>

selection(

cursor: Cursor<T>,

pages: Pages<any>

): undefined | Selection<T>

toType(

schema: Schema<any>,

): Type<T>

}

export type TypeOf<T>

= Store.TypeOf<T>

export function Welcome(): Element

/**

Create a workspace */

export function workspace<T>(

label: Label,

options: WorkspaceOptions<T>

): WorkspaceConfig<T>

/**

Use a workspace to divide content. It is possible to create internal links between workspaces. */

export class Workspace<T = any> implements WorkspaceConfig<T>

{

constructor<T = any>(

config: WorkspaceConfig<T>

): Workspace<T>

config: WorkspaceConfig<T>

label: Label

options: WorkspaceOptions<T>

roots: Record<string, Root<string>>

schema: Schema<T>

get color(): string

get mediaDir(): undefined | string

get preview(): undefined | ComponentType<{entry: T, previewToken: string}>

get source(): string

get typeNamespace(): undefined | string

}