@kyro-cms/core 0.1.0

package/dist/types-BGM5MV_K.d.cts

@@ -0,0 +1,589 @@
+interface FieldAdmin {
+    description?: string;
+    placeholder?: string;
+    readOnly?: boolean;
+    hidden?: boolean;
+    width?: string;
+    condition?: (data: Record<string, any>, siblingData: Record<string, any>) => boolean;
+    position?: 'sidebar' | 'main';
+}
+interface BaseField {
+    name: string;
+    label?: string;
+    required?: boolean;
+    unique?: boolean;
+    indexed?: boolean;
+    defaultValue?: any;
+    admin?: FieldAdmin;
+    validate?: (value: any, options: ValidateOptions) => string | true | Promise<string | true>;
+    hooks?: {
+        beforeValidate?: Hook$1[];
+        beforeChange?: Hook$1[];
+        afterChange?: Hook$1[];
+        afterRead?: Hook$1[];
+    };
+}
+interface ValidateOptions {
+    data?: Record<string, any>;
+    siblingData?: Record<string, any>;
+    user?: any;
+    operation?: string;
+    required?: boolean;
+}
+type Hook$1 = (args: any) => Promise<any> | any;
+type TextFieldVariant = 'text' | 'email' | 'password' | 'url' | 'id';
+interface TextField extends BaseField {
+    type: 'text';
+    variant?: TextFieldVariant;
+    minLength?: number;
+    maxLength?: number;
+    pattern?: string;
+    hasMany?: boolean;
+    localized?: boolean;
+}
+interface NumberField extends BaseField {
+    type: 'number';
+    min?: number;
+    max?: number;
+    step?: number;
+    integer?: boolean;
+    hasMany?: boolean;
+}
+interface CheckboxField extends BaseField {
+    type: 'checkbox';
+}
+interface DateField extends BaseField {
+    type: 'date';
+    minDate?: string;
+    maxDate?: string;
+    time?: boolean;
+}
+interface EmailField extends BaseField {
+    type: 'email';
+}
+interface PasswordField extends BaseField {
+    type: 'password';
+}
+interface TextareaField extends BaseField {
+    type: 'textarea';
+    minLength?: number;
+    maxLength?: number;
+    rows?: number;
+    localized?: boolean;
+}
+interface SelectField extends BaseField {
+    type: 'select';
+    options: Array<{
+        label: string;
+        value: string;
+    }>;
+    hasMany?: boolean;
+    defaultValue?: string | string[];
+}
+interface RadioField extends BaseField {
+    type: 'radio';
+    options: Array<{
+        label: string;
+        value: string;
+    }>;
+    defaultValue?: string;
+}
+interface ColorField extends BaseField {
+    type: 'color';
+    format?: 'hex' | 'rgb' | 'hsl';
+    defaultValue?: string;
+}
+interface RichTextBlock {
+    type: string;
+    data: Record<string, any>;
+    children?: RichTextBlock[];
+}
+interface RichTextField extends BaseField {
+    type: 'richtext';
+    editor?: 'lexical' | 'slate' | 'blocks';
+    defaultValue?: RichTextBlock[];
+    localized?: boolean;
+}
+interface JSONField extends BaseField {
+    type: 'json';
+    defaultValue?: Record<string, any>;
+}
+interface CodeField extends BaseField {
+    type: 'code';
+    language?: string;
+    defaultValue?: string;
+}
+interface UploadField extends BaseField {
+    type: 'upload';
+    relationTo: string;
+    hasMany?: boolean;
+    maxDepth?: number;
+    defaultValue?: string;
+}
+interface MarkdownField extends BaseField {
+    type: 'markdown';
+    localized?: boolean;
+    defaultValue?: string;
+}
+interface RelationshipField extends BaseField {
+    type: 'relationship';
+    relationTo: string | string[];
+    hasMany?: boolean;
+    maxDepth?: number;
+    filterOptions?: (args: {
+        data: any;
+        user: any;
+    }) => Record<string, any>;
+    defaultValue?: string | string[];
+}
+interface ArrayField extends BaseField {
+    type: 'array';
+    fields: Field[];
+    minRows?: number;
+    maxRows?: number;
+    labels?: {
+        singular?: string;
+        plural?: string;
+    };
+    defaultValue?: Record<string, any>[];
+}
+interface GroupField extends BaseField {
+    type: 'group';
+    fields: Field[];
+    defaultValue?: Record<string, any>;
+}
+interface Block {
+    slug: string;
+    label: string;
+    fields: Field[];
+    imageURL?: string;
+}
+interface BlocksField extends BaseField {
+    type: 'blocks';
+    blocks: Block[];
+    minRows?: number;
+    maxRows?: number;
+    defaultValue?: Array<{
+        blockType: string;
+        [key: string]: any;
+    }>;
+}
+interface RowField extends Omit<BaseField, 'name'> {
+    type: 'row';
+    fields: Field[];
+    name?: string;
+}
+interface CollapsibleField extends Omit<BaseField, 'name'> {
+    type: 'collapsible';
+    fields: Field[];
+    label: string;
+    name?: string;
+}
+interface TabsField extends Omit<BaseField, 'name'> {
+    type: 'tabs';
+    tabs: Array<{
+        label: string;
+        fields: Field[];
+        name?: string;
+    }>;
+    name?: string;
+}
+type Field = TextField | NumberField | CheckboxField | DateField | EmailField | PasswordField | TextareaField | SelectField | RadioField | ColorField | RichTextField | JSONField | CodeField | UploadField | MarkdownField | RelationshipField | ArrayField | GroupField | BlocksField | RowField | CollapsibleField | TabsField;
+type FieldType = Field['type'];
+declare function isTextField(field: Field): field is TextField;
+declare function isNumberField(field: Field): field is NumberField;
+declare function isRelationshipField(field: Field): field is RelationshipField;
+declare function isArrayField(field: Field): field is ArrayField;
+declare function isGroupField(field: Field): field is GroupField;
+declare function isBlocksField(field: Field): field is BlocksField;
+declare function isUploadField(field: Field): field is UploadField;
+declare function isRichTextField(field: Field): field is RichTextField;
+declare function isSelectField(field: Field): field is SelectField;
+declare function isLayoutField(field: Field): field is RowField | CollapsibleField | TabsField;
+declare const PRIMITIVE_FIELD_TYPES: readonly ["text", "number", "checkbox", "date", "email", "password", "textarea", "select", "radio", "color"];
+declare const COMPLEX_FIELD_TYPES: readonly ["richtext", "json", "code", "upload", "markdown"];
+declare const RELATIONAL_FIELD_TYPES: readonly ["relationship", "array", "group", "blocks"];
+declare const LAYOUT_FIELD_TYPES: readonly ["row", "collapsible", "tabs"];
+declare const ALL_FIELD_TYPES: readonly ["text", "number", "checkbox", "date", "email", "password", "textarea", "select", "radio", "color", "richtext", "json", "code", "upload", "markdown", "relationship", "array", "group", "blocks", "row", "collapsible", "tabs"];
+
+interface Request {
+    body?: any;
+    headers: Record<string, string>;
+    method?: string;
+    url?: string;
+    cookies?: Record<string, string>;
+    query?: Record<string, any>;
+}
+interface User {
+    id: string;
+    email: string;
+    role: string;
+    tenantID?: string;
+    [key: string]: any;
+}
+interface HookArgs<T = any> {
+    collection?: string;
+    global?: string;
+    data?: T;
+    originalDoc?: T;
+    doc?: T;
+    req: Request;
+    user?: User;
+    operation: 'create' | 'read' | 'update' | 'delete';
+    tenantID?: string;
+    field?: string;
+    siblingData?: Record<string, any>;
+    value?: any;
+    previousValue?: any;
+    context?: Record<string, any>;
+}
+type Hook<T = any> = (args: HookArgs<T>) => Promise<T | void> | T | void;
+interface CollectionHooks {
+    beforeValidate?: Hook[];
+    beforeChange?: Hook[];
+    afterChange?: Hook[];
+    beforeRead?: Hook[];
+    afterRead?: Hook[];
+    beforeDelete?: Hook[];
+    afterDelete?: Hook[];
+    beforeLogin?: Hook[];
+    afterLogin?: Hook[];
+    afterLogout?: Hook[];
+    afterRefresh?: Hook[];
+    afterForgotPassword?: Hook[];
+}
+interface FieldHooks {
+    beforeValidate?: Hook[];
+    beforeChange?: Hook[];
+    afterChange?: Hook[];
+    afterRead?: Hook[];
+}
+interface GlobalHooks {
+    beforeValidate?: Hook[];
+    beforeChange?: Hook[];
+    afterChange?: Hook[];
+    beforeRead?: Hook[];
+    afterRead?: Hook[];
+}
+declare function runHooks(hooks: Hook[], args: HookArgs): Promise<any>;
+declare function runFieldHooks(hooks: Hook[], args: HookArgs): Promise<any>;
+
+interface WhereClause {
+    [field: string]: any;
+}
+interface AccessArgs {
+    req: Request;
+    user?: User;
+    data?: any;
+    doc?: any;
+    id?: string;
+    tenantID?: string;
+    context?: Record<string, any>;
+}
+type AccessControl = boolean | ((args: AccessArgs) => Promise<boolean | WhereClause> | boolean | WhereClause);
+interface CollectionAccess {
+    create?: AccessControl;
+    read?: AccessControl;
+    update?: AccessControl;
+    delete?: AccessControl;
+    admin?: AccessControl;
+    unlock?: AccessControl;
+    readVersions?: AccessControl;
+}
+interface GlobalAccess {
+    read?: AccessControl;
+    update?: AccessControl;
+}
+interface FieldAccess {
+    create?: AccessControl;
+    read?: AccessControl;
+    update?: AccessControl;
+}
+declare function evaluateAccess(access: AccessControl, args: AccessArgs): Promise<boolean | WhereClause>;
+declare function mergeWhereClauses(...whereClauses: (WhereClause | boolean | undefined)[]): WhereClause;
+declare function getWhereClause(access: AccessControl, args: AccessArgs): Promise<WhereClause | undefined>;
+
+interface AdminConfig {
+    useAsTitle?: string;
+    defaultColumns?: string[];
+    hidden?: boolean;
+    description?: string;
+    hideAPIURL?: boolean;
+    group?: string;
+    icon?: string;
+    preview?: (doc: any, options: {
+        req: any;
+    }) => string;
+    disableDuplicate?: boolean;
+    pagination?: {
+        defaultLimit?: number;
+        limits?: number[];
+    };
+}
+interface UploadConfig {
+    staticDir?: string;
+    staticURL?: string;
+    mimeTypes?: string[];
+    fileSize?: number;
+    imageSizes?: ImageSize[];
+    crop?: boolean;
+    focalPoint?: boolean;
+    formatOptions?: {
+        format: 'webp' | 'png' | 'jpg';
+        options?: Record<string, any>;
+    };
+    resizeOptions?: Record<string, any>;
+    adminThumbnail?: string;
+}
+interface ImageSize {
+    name: string;
+    width?: number;
+    height?: number;
+    crop?: string;
+    position?: string;
+    formatOptions?: {
+        format: 'webp' | 'png' | 'jpg';
+    };
+    generateImageName?: (doc: any) => string;
+}
+interface VersionConfig {
+    maxPerDoc?: number;
+    drafts?: boolean;
+    retainDeleted?: boolean;
+}
+interface AuthConfig {
+    tokenExpiration?: number;
+    verify?: boolean | {
+        generateEmailHTML?: (args: any) => string;
+    };
+    maxLoginAttempts?: number;
+    lockTime?: number;
+    cookies?: {
+        secure?: boolean;
+        sameSite?: 'strict' | 'lax' | 'none';
+        domain?: string;
+    };
+    forgotPassword?: {
+        generateEmailHTML?: (args: any) => string;
+        generateEmailSubject?: (args: any) => string;
+    };
+    strategies?: Array<{
+        name: string;
+        authenticate: (args: any) => Promise<any>;
+    }>;
+}
+interface CollectionConfig {
+    slug: string;
+    label?: string;
+    labelPlural?: string;
+    singularLabel?: string;
+    admin?: AdminConfig;
+    fields: Field[];
+    access?: CollectionAccess;
+    hooks?: CollectionHooks;
+    timestamps?: boolean;
+    tenantScoped?: boolean;
+    tenantField?: string;
+    upload?: UploadConfig;
+    versions?: VersionConfig;
+    auth?: boolean | AuthConfig;
+    graphQL?: {
+        singularName?: string;
+        pluralName?: string;
+    };
+    indexes?: Array<{
+        fields: Record<string, number | 'text'>;
+        options?: Record<string, any>;
+    }>;
+    typescript?: {
+        interface?: string;
+    };
+    custom?: Record<string, any>;
+}
+interface GlobalConfig {
+    slug: string;
+    label?: string;
+    admin?: AdminConfig;
+    fields: Field[];
+    access?: GlobalAccess;
+    hooks?: GlobalHooks;
+    versions?: VersionConfig;
+    graphQL?: {
+        name?: string;
+    };
+    typescript?: {
+        interface?: string;
+    };
+    custom?: Record<string, any>;
+}
+interface FindArgs {
+    collection: string;
+    where?: Record<string, any>;
+    sort?: string;
+    limit?: number;
+    page?: number;
+    depth?: number;
+    tenantID?: string;
+    select?: string[];
+    user?: any;
+    context?: Record<string, any>;
+    overrideAccess?: boolean;
+}
+interface FindByIDArgs {
+    collection: string;
+    id: string;
+    depth?: number;
+    tenantID?: string;
+    select?: string[];
+    user?: any;
+    context?: Record<string, any>;
+    overrideAccess?: boolean;
+}
+interface CreateArgs {
+    collection: string;
+    data: Record<string, any>;
+    depth?: number;
+    tenantID?: string;
+    select?: string[];
+    user?: any;
+    context?: Record<string, any>;
+    overrideAccess?: boolean;
+}
+interface UpdateArgs {
+    collection: string;
+    id: string;
+    data: Record<string, any>;
+    depth?: number;
+    tenantID?: string;
+    select?: string[];
+    user?: any;
+    context?: Record<string, any>;
+    overrideAccess?: boolean;
+}
+interface DeleteArgs {
+    collection: string;
+    id: string;
+    tenantID?: string;
+    user?: any;
+    context?: Record<string, any>;
+    overrideAccess?: boolean;
+}
+interface FindResult<T = any> {
+    docs: T[];
+    totalDocs: number;
+    limit: number;
+    totalPages: number;
+    page: number;
+    pagingCounter: number;
+    hasPrevPage: boolean;
+    hasNextPage: boolean;
+    prevPage: number | null;
+    nextPage: number | null;
+}
+interface CreateResult<T = any> {
+    doc: T;
+    errors?: Array<{
+        field: string;
+        message: string;
+    }>;
+}
+interface BaseAdapter {
+    init(collections: CollectionConfig[], globals: GlobalConfig[]): Promise<void>;
+    find<T>(args: FindArgs): Promise<FindResult<T>>;
+    findByID<T>(args: FindByIDArgs): Promise<T | null>;
+    create<T>(args: CreateArgs): Promise<T>;
+    update<T>(args: UpdateArgs): Promise<T>;
+    delete<T>(args: DeleteArgs): Promise<T>;
+    count(args: {
+        collection: string;
+        where?: Record<string, any>;
+        tenantID?: string;
+    }): Promise<number>;
+    findOne(args: {
+        collection: string;
+        where: Record<string, any>;
+        tenantID?: string;
+    }): Promise<any>;
+    findVersions(args: FindArgs): Promise<FindResult<any>>;
+    findVersionByID(args: FindByIDArgs): Promise<any>;
+    createVersion(args: CreateArgs): Promise<any>;
+    deleteVersions(args: {
+        collection: string;
+        where: Record<string, any>;
+    }): Promise<void>;
+    migrate?(): Promise<void>;
+    rollback?(): Promise<void>;
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    transaction?<T>(fn: (tx: any) => Promise<T>): Promise<T>;
+}
+interface AdapterConfig {
+    type: 'drizzle' | 'mongodb';
+    client: any;
+    schema?: any;
+    connectionOptions?: Record<string, any>;
+}
+interface PluginConfig {
+    name: string;
+    version?: string;
+    init?: (kyro: any) => void | Promise<void>;
+    extendCollection?: (slug: string, config: CollectionConfig) => CollectionConfig;
+    extendGlobal?: (slug: string, config: GlobalConfig) => GlobalConfig;
+    hooks?: CollectionHooks;
+    fields?: Field[];
+    api?: (kyro: any) => any;
+}
+interface KyroConfig {
+    collections?: CollectionConfig[];
+    globals?: GlobalConfig[];
+    adapter: BaseAdapter;
+    plugins?: PluginConfig[];
+    auth?: {
+        secret: string;
+        tokenExpiration?: number;
+        cookie?: {
+            secure?: boolean;
+            sameSite?: 'strict' | 'lax' | 'none';
+            domain?: string;
+        };
+    };
+    cors?: {
+        origins?: string[];
+        credentials?: boolean;
+    };
+    admin?: {
+        meta?: {
+            title?: string;
+            description?: string;
+            ogImage?: string;
+        };
+        dateFormat?: string;
+        avatar?: 'default' | 'gravatar';
+        disable?: boolean;
+        indexRoute?: string;
+        components?: Record<string, any>;
+    };
+    upload?: {
+        limits?: {
+            fileSize?: number;
+        };
+    };
+    graphQL?: {
+        maxComplexity?: number;
+        disablePlayground?: boolean;
+    };
+    typescript?: {
+        outputFile?: string;
+    };
+    localization?: {
+        locales: string[];
+        defaultLocale: string;
+    };
+    rateLimit?: {
+        window?: number;
+        max?: number;
+    };
+    debug?: boolean;
+}
+
+export { type RadioField as $, ALL_FIELD_TYPES as A, type BaseAdapter as B, type CollectionConfig as C, type DeleteArgs as D, type EmailField as E, type Field as F, type GlobalConfig as G, type Hook as H, type FieldAdmin as I, type FieldHooks as J, type KyroConfig as K, type FieldType as L, type GlobalAccess as M, type GlobalHooks as N, type GroupField as O, type PluginConfig as P, type HookArgs as Q, type RelationshipField as R, type ImageSize as S, type JSONField as T, type UpdateArgs as U, LAYOUT_FIELD_TYPES as V, type MarkdownField as W, type NumberField as X, PRIMITIVE_FIELD_TYPES as Y, type PasswordField as Z, RELATIONAL_FIELD_TYPES as _, type FindArgs as a, type RichTextBlock as a0, type RichTextField as a1, type RowField as a2, type SelectField as a3, type TabsField as a4, type TextField as a5, type TextareaField as a6, type UploadConfig as a7, type ValidateOptions as a8, type VersionConfig as a9, type WhereClause as aa, evaluateAccess as ab, getWhereClause as ac, isArrayField as ad, isBlocksField as ae, isGroupField as af, isLayoutField as ag, isNumberField as ah, isRelationshipField as ai, isRichTextField as aj, isSelectField as ak, isTextField as al, isUploadField as am, mergeWhereClauses as an, runFieldHooks as ao, runHooks as ap, type FindResult as b, type FindByIDArgs as c, type CreateArgs as d, type UploadField as e, type User as f, type Request as g, type AccessArgs as h, type AccessControl as i, type AdapterConfig as j, type AdminConfig as k, type ArrayField as l, type AuthConfig as m, type BaseField as n, type Block as o, type BlocksField as p, COMPLEX_FIELD_TYPES as q, type CheckboxField as r, type CodeField as s, type CollapsibleField as t, type CollectionAccess as u, type CollectionHooks as v, type ColorField as w, type CreateResult as x, type DateField as y, type FieldAccess as z };