@oberoncms/core/dist/lib/dtd.d.ts

OberonCMS is a cloud deployable CMS written in typescript based on the Puck visual editor

import { z } from "zod";
import { Data } from "@measured/puck";
import { Route } from "next";
import type { ComponentConfig, Config, DefaultComponentProps } from "@measured/puck";
import type { AdapterUser, Adapter as AuthAdapter } from "@auth/core/adapters";
import type { StreamResponseChunk } from "@tohuhono/utils";
import type { Awaitable } from "@auth/core/types";
import type { NextRequest } from "next/server";
export declare class OberonError extends Error {
}
export declare class ResponseError extends Error {
}
type Transforms = Array<(props: any) => any>;
export type PageData = Data;
export type OberonConfig = Config & {
    version: 1;
    components: Record<string, {
        transforms?: Transforms;
    }>;
};
export type OberonComponent<ComponentProps extends DefaultComponentProps = DefaultComponentProps, Transforms extends Array<(props: Record<string, unknown>) => Record<string, unknown>> = Array<(props: Record<string, unknown>) => Record<string, unknown>>> = ComponentConfig<ComponentProps> & {
    transforms?: Transforms;
};
export declare const clientActions: readonly ["edit", "preview", "users", "images", "pages", "site", "login"];
export declare const actionPaths: {
    path: ("edit" | "preview" | "users" | "images" | "pages" | "site" | "login")[];
}[];
export type ClientAction = (typeof clientActions)[number];
export type AdapterActionGroup = "all" | "users" | "images" | "pages" | "site";
export type AdapterPermission = "unauthenticated" | "read" | "write";
export type OberonRole = "user" | "admin";
export type OberonPermissions = Record<"unauthenticated" | "user", Partial<Record<AdapterActionGroup, AdapterPermission>>>;
export declare const INITIAL_DATA: {
    content: never[];
    root: {
        props: {
            title: string;
        };
    };
};
export type MaybeOptimistic<T> = T & {
    pending?: boolean;
};
export declare const PageSchema: z.ZodObject<{
    key: z.ZodString;
    data: z.ZodObject<{}, "passthrough", z.ZodTypeAny, z.objectOutputType<{}, z.ZodTypeAny, "passthrough">, z.objectInputType<{}, z.ZodTypeAny, "passthrough">>;
    updatedAt: z.ZodDate;
    updatedBy: z.ZodString;
}, "strip", z.ZodTypeAny, {
    key: string;
    data: {} & {
        [k: string]: unknown;
    };
    updatedAt: Date;
    updatedBy: string;
}, {
    key: string;
    data: {} & {
        [k: string]: unknown;
    };
    updatedAt: Date;
    updatedBy: string;
}>;
export declare const AddPageSchema: z.ZodObject<Pick<{
    key: z.ZodString;
    data: z.ZodObject<{}, "passthrough", z.ZodTypeAny, z.objectOutputType<{}, z.ZodTypeAny, "passthrough">, z.objectInputType<{}, z.ZodTypeAny, "passthrough">>;
    updatedAt: z.ZodDate;
    updatedBy: z.ZodString;
}, "key">, "strip", z.ZodTypeAny, {
    key: string;
}, {
    key: string;
}>;
export declare const DeletePageSchema: z.ZodObject<Pick<{
    key: z.ZodString;
    data: z.ZodObject<{}, "passthrough", z.ZodTypeAny, z.objectOutputType<{}, z.ZodTypeAny, "passthrough">, z.objectInputType<{}, z.ZodTypeAny, "passthrough">>;
    updatedAt: z.ZodDate;
    updatedBy: z.ZodString;
}, "key">, "strip", z.ZodTypeAny, {
    key: string;
}, {
    key: string;
}>;
export declare const PublishPageSchema: z.ZodObject<Pick<{
    key: z.ZodString;
    data: z.ZodObject<{}, "passthrough", z.ZodTypeAny, z.objectOutputType<{}, z.ZodTypeAny, "passthrough">, z.objectInputType<{}, z.ZodTypeAny, "passthrough">>;
    updatedAt: z.ZodDate;
    updatedBy: z.ZodString;
}, "key" | "data">, "strip", z.ZodTypeAny, {
    key: string;
    data: {} & {
        [k: string]: unknown;
    };
}, {
    key: string;
    data: {} & {
        [k: string]: unknown;
    };
}>;
export declare const PageMetaSchema: z.ZodObject<Pick<{
    key: z.ZodString;
    data: z.ZodObject<{}, "passthrough", z.ZodTypeAny, z.objectOutputType<{}, z.ZodTypeAny, "passthrough">, z.objectInputType<{}, z.ZodTypeAny, "passthrough">>;
    updatedAt: z.ZodDate;
    updatedBy: z.ZodString;
}, "key" | "updatedAt" | "updatedBy">, "strip", z.ZodTypeAny, {
    key: string;
    updatedAt: Date;
    updatedBy: string;
}, {
    key: string;
    updatedAt: Date;
    updatedBy: string;
}>;
export type OberonPage = z.infer<typeof PageSchema> & {
    data: PageData;
    key: Route;
};
export type OberonPageMeta = MaybeOptimistic<z.infer<typeof PageMetaSchema> & {
    key: Route;
}>;
export declare const ImageSchema: z.ZodObject<{
    key: z.ZodString;
    url: z.ZodString;
    size: z.ZodNumber;
    width: z.ZodNumber;
    height: z.ZodNumber;
    alt: z.ZodString;
    updatedAt: z.ZodDate;
    updatedBy: z.ZodString;
}, "strip", z.ZodTypeAny, {
    key: string;
    updatedAt: Date;
    updatedBy: string;
    url: string;
    size: number;
    width: number;
    height: number;
    alt: string;
}, {
    key: string;
    updatedAt: Date;
    updatedBy: string;
    url: string;
    size: number;
    width: number;
    height: number;
    alt: string;
}>;
export declare const AddImageSchema: z.ZodObject<{
    key: z.ZodString;
    url: z.ZodString;
    size: z.ZodNumber;
    width: z.ZodNumber;
    height: z.ZodNumber;
    alt: z.ZodString;
    updatedAt: z.ZodDate;
    updatedBy: z.ZodString;
}, "strip", z.ZodTypeAny, {
    key: string;
    updatedAt: Date;
    updatedBy: string;
    url: string;
    size: number;
    width: number;
    height: number;
    alt: string;
}, {
    key: string;
    updatedAt: Date;
    updatedBy: string;
    url: string;
    size: number;
    width: number;
    height: number;
    alt: string;
}>;
export declare const DeleteImageSchema: z.ZodObject<Pick<{
    key: z.ZodString;
    url: z.ZodString;
    size: z.ZodNumber;
    width: z.ZodNumber;
    height: z.ZodNumber;
    alt: z.ZodString;
    updatedAt: z.ZodDate;
    updatedBy: z.ZodString;
}, "key">, "strip", z.ZodTypeAny, {
    key: string;
}, {
    key: string;
}>;
export type OberonImage = MaybeOptimistic<z.infer<typeof ImageSchema>>;
export declare const UserSchema: z.ZodObject<{
    id: z.ZodString;
    email: z.ZodString;
    role: z.ZodEnum<["user", "admin"]>;
}, "strip", z.ZodTypeAny, {
    id: string;
    email: string;
    role: "user" | "admin";
}, {
    id: string;
    email: string;
    role: "user" | "admin";
}>;
export declare const AddUserSchema: z.ZodObject<Pick<{
    id: z.ZodString;
    email: z.ZodString;
    role: z.ZodEnum<["user", "admin"]>;
}, "email" | "role">, "strip", z.ZodTypeAny, {
    email: string;
    role: "user" | "admin";
}, {
    email: string;
    role: "user" | "admin";
}>;
export declare const ChangeRoleSchema: z.ZodObject<Pick<{
    id: z.ZodString;
    email: z.ZodString;
    role: z.ZodEnum<["user", "admin"]>;
}, "id" | "role">, "strip", z.ZodTypeAny, {
    id: string;
    role: "user" | "admin";
}, {
    id: string;
    role: "user" | "admin";
}>;
export declare const DeleteUserSchema: z.ZodObject<Pick<{
    id: z.ZodString;
    email: z.ZodString;
    role: z.ZodEnum<["user", "admin"]>;
}, "id">, "strip", z.ZodTypeAny, {
    id: string;
}, {
    id: string;
}>;
export type OberonUser = MaybeOptimistic<z.infer<typeof UserSchema>>;
export declare const roles: OberonRole[];
type DescriminatedContext = {
    action: "edit" | "preview";
    data: Data | null;
} | {
    action: "users";
    data: OberonUser[];
} | {
    action: "images";
    data: OberonImage[];
} | {
    action: "pages";
    data: OberonPageMeta[];
} | {
    action: "site";
    data: OberonSiteConfig;
} | {
    action: "login";
    data: {
        callbackUrl: string;
        email: string;
        token: string;
    };
};
export type OberonClientContext = DescriminatedContext & {
    slug: string;
};
type TransformStatus = "error" | "success";
export type TransformResult = {
    type: "transform";
    key: string;
    status: "success" | "error";
};
export type MigrationResult = {
    type: "summary";
    total: number;
} & {
    [key in TransformStatus]: string[];
};
export type TransformVersions = Record<string, number>;
export type PluginVersion = Pick<ReturnType<OberonPlugin>, "name" | "version" | "disabled">;
export type OberonSiteConfig = MaybeOptimistic<{
    version: string;
    plugins: PluginVersion[];
    components: TransformVersions;
    pendingMigrations: string[] | false;
}>;
export declare const SiteSchema: z.ZodObject<{
    version: z.ZodNumber;
    components: z.ZodRecord<z.ZodString, z.ZodNumber>;
    updatedAt: z.ZodDate;
    updatedBy: z.ZodString;
}, "strip", z.ZodTypeAny, {
    updatedAt: Date;
    updatedBy: string;
    version: number;
    components: Record<string, number>;
}, {
    updatedAt: Date;
    updatedBy: string;
    version: number;
    components: Record<string, number>;
}>;
export type OberonSite = z.infer<typeof SiteSchema>;
export type OberonCanAdapter = {
    getCurrentUser: () => Promise<OberonUser | null>;
    hasPermission: (props: {
        user?: OberonUser | null;
        action: AdapterActionGroup;
        permission: AdapterPermission;
    }) => boolean;
    signIn: (data: {
        email: string;
    }) => Promise<void>;
    signOut: () => Promise<void>;
};
export type OberonAuthAdapter = Required<Pick<AuthAdapter, "createSession" | "createUser" | "createVerificationToken" | "deleteSession" | "deleteUser" | "getSessionAndUser" | "getUser" | "getUserByAccount" | "getUserByEmail" | "linkAccount" | "unlinkAccount" | "updateSession" | "updateUser" | "useVerificationToken">> & {
    createUser(user: Omit<AdapterUser & {
        role: OberonRole;
    }, "id">): Awaitable<AdapterUser & {
        role: OberonRole;
    }>;
    deleteUser: (id: OberonUser["id"]) => Promise<void>;
};
export type OberonBaseAdapter = {
    addPage: (page: OberonPage) => Promise<void>;
    addImage: (data: z.infer<typeof ImageSchema>) => Promise<void>;
    addUser: (data: z.infer<typeof AddUserSchema>) => Promise<OberonUser>;
    deletePage: (key: OberonPageMeta["key"]) => Promise<void>;
    deleteImage: (key: OberonImage["key"]) => Promise<void>;
    deleteUser: (id: OberonUser["id"]) => Promise<void>;
    changeRole: (data: z.infer<typeof ChangeRoleSchema>) => Promise<void>;
    getAllImages: () => Promise<OberonImage[]>;
    getAllPages: () => Promise<OberonPageMeta[]>;
    getAllUsers: () => Promise<OberonUser[]>;
    getPageData: (key: OberonPageMeta["key"]) => Promise<Data | null>;
    getSite: () => Promise<OberonSite | undefined>;
    updatePageData: (data: OberonPage) => Promise<void>;
    updateSite: (data: z.infer<typeof SiteSchema>) => Promise<void>;
};
export type OberonSendAdapter = {
    sendVerificationRequest: (props: {
        email: string;
        token: string;
        url: string;
    }) => Promise<void>;
};
export type OberonInitAdapter = {
    prebuild: () => Promise<void>;
};
export type OberonDatabaseAdapter = OberonBaseAdapter & OberonAuthAdapter;
export type OberonPluginAdapter = OberonInitAdapter & OberonDatabaseAdapter & OberonCanAdapter & OberonSendAdapter;
export type OberonMethod = "GET" | "POST" | "PUT" | "PATCH" | "DELETE";
export type OberonHandler<Params = undefined> = Params extends undefined ? {
    [key in OberonMethod]?: (req: NextRequest) => Promise<Response> | Response;
} : {
    [key in OberonMethod]: (req: NextRequest, context: {
        params: Promise<Params>;
    }) => Promise<Response>;
};
export type OberonAdapter = {
    prebuild: () => Promise<void>;
    addPage: (page: z.infer<typeof AddPageSchema>) => Promise<void>;
    addImage: (data: OberonImage) => Promise<OberonImage[]>;
    addUser: (data: z.infer<typeof AddUserSchema>) => Promise<OberonUser | null>;
    deletePage: (data: z.infer<typeof DeletePageSchema>) => Promise<void>;
    deleteImage: (key: OberonImage["key"]) => Promise<void>;
    deleteUser: (data: z.infer<typeof DeleteUserSchema>) => Promise<Pick<OberonUser, "id"> | null>;
    can: (action: AdapterActionGroup, permission?: AdapterPermission) => Promise<boolean>;
    changeRole: (data: z.infer<typeof ChangeRoleSchema>) => Promise<Pick<OberonUser, "role" | "id"> | null>;
    getAllImages: () => Promise<OberonImage[]>;
    getAllPages: () => Promise<OberonPageMeta[]>;
    getAllPaths: () => Promise<Array<{
        path: string[];
    }>>;
    getAllUsers: () => Promise<OberonUser[]>;
    getConfig: () => Promise<OberonSiteConfig>;
    getPageData: (key: OberonPageMeta["key"]) => Promise<Data | null>;
    migrateData: () => Promise<StreamResponseChunk<TransformResult | MigrationResult>>;
    publishPageData: (data: z.infer<typeof PublishPageSchema>) => Promise<{
        message: string;
    }>;
    signOut: () => Promise<void>;
    signIn: (data: {
        email: string;
    }) => Promise<void>;
};
export type OberonPlugin = (adapter: OberonPluginAdapter) => {
    name: string;
    version?: string;
    disabled?: boolean;
    handlers?: Record<string, (adapter: OberonAdapter) => OberonHandler>;
    adapter?: Partial<OberonPluginAdapter>;
};
export type OberonResponse<T = unknown> = Promise<{
    status: "success";
    result: T;
    message?: string;
} | {
    status: "error";
    result?: T;
    message?: string;
}>;
export type OberonServerActions = {
    addPage: (page: z.infer<typeof AddPageSchema>) => OberonResponse<void>;
    addImage: (data: OberonImage) => OberonResponse<OberonImage[]>;
    addUser: (data: z.infer<typeof AddUserSchema>) => OberonResponse<OberonUser | null>;
    deletePage: (data: z.infer<typeof DeletePageSchema>) => OberonResponse;
    deleteImage: (key: OberonImage["key"]) => OberonResponse;
    deleteUser: (data: z.infer<typeof DeleteUserSchema>) => OberonResponse<Pick<OberonUser, "id"> | null>;
    can: (action: AdapterActionGroup, permission?: AdapterPermission) => OberonResponse<boolean>;
    changeRole: (data: z.infer<typeof ChangeRoleSchema>) => OberonResponse<Pick<OberonUser, "role" | "id"> | null>;
    getAllImages: () => OberonResponse<OberonImage[]>;
    getAllPages: () => OberonResponse<OberonPageMeta[]>;
    getAllPaths: () => OberonResponse<Array<{
        path: string[];
    }>>;
    getAllUsers: () => OberonResponse<OberonUser[]>;
    getConfig: () => OberonResponse<OberonSiteConfig>;
    getPageData: (key: OberonPageMeta["key"]) => OberonResponse<Data | null>;
    migrateData: () => OberonResponse<StreamResponseChunk<TransformResult | MigrationResult>>;
    publishPageData: (data: z.infer<typeof PublishPageSchema>) => OberonResponse;
    signIn: (data: {
        email: string;
    }) => OberonResponse;
    signOut: () => OberonResponse;
};
export {};
//# sourceMappingURL=dtd.d.ts.map