@rakun-kit/core 1.0.0

package/dist/esm/api/context.d.ts

@@ -0,0 +1,31 @@
+import { ManagerUserSchema } from "../internal-content-types";
+export type CookieOptions = {
+    httpOnly?: boolean;
+    secure?: boolean;
+    sameSite?: "lax" | "strict" | "none";
+    path?: string;
+    maxAge?: number;
+    domain?: string;
+};
+export type RakunRequestContext = {
+    req?: {
+        headers?: Record<string, string | string[] | undefined>;
+        cookies?: Record<string, string>;
+    };
+    res?: {
+        setHeader: (name: string, value: string | string[]) => void;
+        cookie?: (name: string, value: string, options?: CookieOptions) => void;
+    };
+    user?: ManagerUserSchema | null;
+    getUser: () => ManagerUserSchema;
+};
+export type RakunRequestContextInput = {
+    headers?: Record<string, string | string[] | undefined>;
+    cookies?: Record<string, string>;
+    res: {
+        setHeader: (name: string, value: string | string[]) => void;
+        cookie?: (name: string, value: string, options?: CookieOptions) => void;
+    };
+};
+export declare const createRequestContext: (input: RakunRequestContextInput) => Promise<RakunRequestContext>;
+//# sourceMappingURL=context.d.ts.map

package/dist/esm/api/context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"context.d.ts","sourceRoot":"","sources":["../../../src/api/context.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,2BAA2B,CAAC;AAI9D,MAAM,MAAM,aAAa,GAAG;IAC1B,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,QAAQ,CAAC,EAAE,KAAK,GAAG,QAAQ,GAAG,MAAM,CAAC;IACrC,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB,CAAC;AAEF,MAAM,MAAM,mBAAmB,GAAG;IAChC,GAAG,CAAC,EAAE;QACJ,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,SAAS,CAAC,CAAC;QACxD,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;KAClC,CAAC;IACF,GAAG,CAAC,EAAE;QACJ,SAAS,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE,KAAK,IAAI,CAAC;QAC5D,MAAM,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,aAAa,KAAK,IAAI,CAAC;KACzE,CAAC;IACF,IAAI,CAAC,EAAE,iBAAiB,GAAG,IAAI,CAAC;IAChC,OAAO,EAAE,MAAM,iBAAiB,CAAC;CAClC,CAAC;AAEF,MAAM,MAAM,wBAAwB,GAAG;IACrC,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,SAAS,CAAC,CAAC;IACxD,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACjC,GAAG,EAAE;QACH,SAAS,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE,KAAK,IAAI,CAAC;QAC5D,MAAM,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,aAAa,KAAK,IAAI,CAAC;KACzE,CAAC;CACH,CAAC;AAEF,eAAO,MAAM,oBAAoB,GAC/B,OAAO,wBAAwB,KAC9B,OAAO,CAAC,mBAAmB,CAyB7B,CAAC"}

package/dist/esm/api/context.js

@@ -0,0 +1,26 @@
+import { throwAppError } from "../lib/errors";
+import { getUser } from "./utils/getUser";
+export const createRequestContext = async (input) => {
+    const ctx = {
+        req: {
+            headers: input.headers,
+            cookies: input.cookies ?? {},
+        },
+        res: input.res,
+        getUser() {
+            return {};
+        },
+    };
+    const user = await getUser(ctx);
+    return {
+        ...ctx,
+        user,
+        getUser() {
+            if (!user) {
+                throwAppError("AUTH_REQUIRED");
+            }
+            return user;
+        },
+    };
+};
+//# sourceMappingURL=context.js.map

package/dist/esm/api/context.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"context.js","sourceRoot":"","sources":["../../../src/api/context.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AAC9C,OAAO,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAC;AAiC1C,MAAM,CAAC,MAAM,oBAAoB,GAAG,KAAK,EACvC,KAA+B,EACD,EAAE;IAChC,MAAM,GAAG,GAAwB;QAC/B,GAAG,EAAE;YACH,OAAO,EAAE,KAAK,CAAC,OAAO;YACtB,OAAO,EAAE,KAAK,CAAC,OAAO,IAAI,EAAE;SAC7B;QACD,GAAG,EAAE,KAAK,CAAC,GAAG;QACd,OAAO;YACL,OAAO,EAAuB,CAAC;QACjC,CAAC;KACF,CAAC;IAEF,MAAM,IAAI,GAAG,MAAM,OAAO,CAAC,GAAG,CAAC,CAAC;IAEhC,OAAO;QACL,GAAG,GAAG;QACN,IAAI;QACJ,OAAO;YACL,IAAI,CAAC,IAAI,EAAE,CAAC;gBACV,aAAa,CAAC,eAAe,CAAC,CAAC;YACjC,CAAC;YAED,OAAO,IAAI,CAAC;QACd,CAAC;KACF,CAAC;AACJ,CAAC,CAAC"}

package/dist/esm/api/operations/custom.d.ts

@@ -0,0 +1,5 @@
+import type { RakunOperationMap } from "./types";
+export type RakunOperationNamespace = "manager" | "web" | "unscoped";
+export declare const getCustomApiOperationDefinitions: (namespace?: RakunOperationNamespace) => RakunOperationMap;
+export declare const mergeOperationMaps: <TBase extends RakunOperationMap, TExtra extends RakunOperationMap>(base: TBase, extra: TExtra) => TBase & TExtra;
+//# sourceMappingURL=custom.d.ts.map

package/dist/esm/api/operations/custom.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"custom.d.ts","sourceRoot":"","sources":["../../../../src/api/operations/custom.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,SAAS,CAAC;AAEjD,MAAM,MAAM,uBAAuB,GAAG,SAAS,GAAG,KAAK,GAAG,UAAU,CAAC;AAyBrE,eAAO,MAAM,gCAAgC,GAC3C,YAAY,uBAAuB,KAClC,iBAIF,CAAC;AAEF,eAAO,MAAM,kBAAkB,GAC7B,KAAK,SAAS,iBAAiB,EAC/B,MAAM,SAAS,iBAAiB,EAEhC,MAAM,KAAK,EACX,OAAO,MAAM,KACZ,KAAK,GAAG,MAaV,CAAC"}

package/dist/esm/api/operations/custom.js

@@ -0,0 +1,25 @@
+import { getRakunBootstrapOptions } from "../../bootstrapState";
+const filterOperationsByNamespace = (operations, namespace) => {
+    if (!namespace) {
+        return operations;
+    }
+    if (namespace === "unscoped") {
+        return Object.fromEntries(Object.entries(operations).filter(([name]) => !name.startsWith("manager.") && !name.startsWith("web.")));
+    }
+    return Object.fromEntries(Object.entries(operations).filter(([name]) => name.startsWith(`${namespace}.`)));
+};
+export const getCustomApiOperationDefinitions = (namespace) => {
+    const operations = getRakunBootstrapOptions()?.apiOperations ?? {};
+    return filterOperationsByNamespace(operations, namespace);
+};
+export const mergeOperationMaps = (base, extra) => {
+    const duplicated = Object.keys(extra).filter((name) => name in base);
+    if (duplicated.length > 0) {
+        throw new Error(`Rakun API operation already exists: ${duplicated.join(", ")}`);
+    }
+    return {
+        ...base,
+        ...extra,
+    };
+};
+//# sourceMappingURL=custom.js.map

package/dist/esm/api/operations/custom.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"custom.js","sourceRoot":"","sources":["../../../../src/api/operations/custom.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,wBAAwB,EAAE,MAAM,sBAAsB,CAAC;AAMhE,MAAM,2BAA2B,GAAG,CAClC,UAA6B,EAC7B,SAAmC,EAChB,EAAE;IACrB,IAAI,CAAC,SAAS,EAAE,CAAC;QACf,OAAO,UAAU,CAAC;IACpB,CAAC;IAED,IAAI,SAAS,KAAK,UAAU,EAAE,CAAC;QAC7B,OAAO,MAAM,CAAC,WAAW,CACvB,MAAM,CAAC,OAAO,CAAC,UAAU,CAAC,CAAC,MAAM,CAC/B,CAAC,CAAC,IAAI,CAAC,EAAE,EAAE,CAAC,CAAC,IAAI,CAAC,UAAU,CAAC,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,MAAM,CAAC,CACrE,CACF,CAAC;IACJ,CAAC;IAED,OAAO,MAAM,CAAC,WAAW,CACvB,MAAM,CAAC,OAAO,CAAC,UAAU,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,IAAI,CAAC,EAAE,EAAE,CAC3C,IAAI,CAAC,UAAU,CAAC,GAAG,SAAS,GAAG,CAAC,CACjC,CACF,CAAC;AACJ,CAAC,CAAC;AAEF,MAAM,CAAC,MAAM,gCAAgC,GAAG,CAC9C,SAAmC,EAChB,EAAE;IACrB,MAAM,UAAU,GAAG,wBAAwB,EAAE,EAAE,aAAa,IAAI,EAAE,CAAC;IAEnE,OAAO,2BAA2B,CAAC,UAAU,EAAE,SAAS,CAAC,CAAC;AAC5D,CAAC,CAAC;AAEF,MAAM,CAAC,MAAM,kBAAkB,GAAG,CAIhC,IAAW,EACX,KAAa,EACG,EAAE;IAClB,MAAM,UAAU,GAAG,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,MAAM,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,IAAI,IAAI,CAAC,CAAC;IAErE,IAAI,UAAU,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;QAC1B,MAAM,IAAI,KAAK,CACb,uCAAuC,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAC/D,CAAC;IACJ,CAAC;IAED,OAAO;QACL,GAAG,IAAI;QACP,GAAG,KAAK;KACS,CAAC;AACtB,CAAC,CAAC"}

package/dist/esm/api/operations/index.d.ts

@@ -0,0 +1,396 @@
+export { createManagerOperationContracts, } from "./manager-contract";
+import { createManagerOperationDefinitions } from "./manager";
+export { createWebOperationContracts } from "./web-contract";
+import { createWebOperationDefinitions } from "./web";
+export declare const createRakunOperationDefinitions: () => {
+    [x: string]: import("./types").AnyRakunOperation;
+    "web.languages": import("./types").RakunOperationWithoutInput<{
+        code: string;
+        name: string;
+        default: boolean;
+        _type: "Language";
+        _id: string;
+        parent?: {
+            type: "self";
+            _id: string;
+            contentType: string;
+        } | undefined;
+    }[], "query", "get", "public">;
+    "web.page": import("./types").RakunOperationWithInput<{
+        path: string;
+        search?: string | undefined;
+        headers?: Record<string, string> | undefined;
+    }, {
+        renderMode: "dynamic" | "static";
+        modules: {
+            [x: string]: unknown;
+            _type: string;
+            _id: string;
+        }[];
+        ttl?: number | undefined;
+        layout?: ({
+            type: "module";
+            key: string;
+            module: {
+                [x: string]: unknown;
+                _type: string;
+                _id: string;
+            } | null;
+        } | {
+            type: "content";
+            modules: {
+                [x: string]: unknown;
+                _type: string;
+                _id: string;
+            }[];
+        })[] | undefined;
+        seo?: {
+            _type: "Seo";
+            _id: string;
+            title?: string | undefined;
+            description?: string | undefined;
+        } | undefined;
+        language?: {
+            code: string;
+            name: string;
+            default: boolean;
+            _type: "Language";
+            _id: string;
+            parent?: {
+                type: "self";
+                _id: string;
+                contentType: string;
+            } | undefined;
+        } | undefined;
+        info?: Record<string, unknown> | undefined;
+        redirect?: {
+            to: string;
+            status: number;
+        } | undefined;
+    }, "query", "get", "public">;
+    "web.test": import("./types").RakunOperationWithoutInput<{
+        ok: boolean;
+    }, "query", "get", "public">;
+    "manager.contentTypes": import("./types").RakunOperationWithoutInput<{
+        name: string;
+        fields: Record<string, unknown>;
+        uniques: string[][];
+        menu?: {
+            title: string;
+            icon?: string | undefined;
+            category?: string | undefined;
+        } | undefined;
+        listFields?: string[] | undefined;
+        isHiddenFromManager?: boolean | undefined;
+    }[], "query", "get", "auth">;
+    "manager.languages": import("./types").RakunOperationWithoutInput<{
+        code: string;
+        name: string;
+        default: boolean;
+        _type: "Language";
+        _id: string;
+        parent?: {
+            type: "self";
+            _id: string;
+            contentType: string;
+        } | undefined;
+    }[], "query", "get", "auth">;
+    "manager.regenerateRoutes": import("./types").RakunOperationWithoutInput<{
+        ok: boolean;
+    }, "mutation", "post", "auth">;
+    "manager.create": import("./types").RakunOperationWithInput<{
+        contentType: string;
+        data: any;
+    }, any, "mutation", "post", "auth">;
+    "manager.update": import("./types").RakunOperationWithInput<{
+        contentType: string;
+        id: string;
+        data: any;
+    }, any, "mutation", "post", "auth">;
+    "manager.delete": import("./types").RakunOperationWithInput<{
+        contentType: string;
+        id: string;
+    }, any, "mutation", "post", "auth">;
+    "manager.get": import("./types").RakunOperationWithInput<{
+        contentType: string;
+        id: string;
+    }, any, "query", "post", "auth">;
+    "manager.list": import("./types").RakunOperationWithInput<{
+        contentType: string;
+        query: {
+            filter?: Record<string, any> | undefined;
+            options?: {
+                fields?: string[] | undefined;
+                limit?: number | "all" | undefined;
+                page?: number | undefined;
+                sort?: Record<string, "asc" | "desc"> | undefined;
+            } | undefined;
+        };
+    }, {
+        totalItems: number;
+        items: {
+            [x: string]: any;
+            _id: string;
+        }[];
+    }, "query", "post", "auth">;
+    "manager.setDefaultLanguage": import("./types").RakunOperationWithInput<{
+        language: string;
+    }, {
+        ok: boolean;
+    }, "mutation", "post", "auth">;
+    "manager.permissions": import("./types").RakunOperationWithoutInput<string[], "query", "get", "auth">;
+    "manager.media.prepareUpload": import("./types").RakunOperationWithInput<{
+        fileName: string;
+        mime: string;
+        size: number;
+        access?: "public" | "private" | undefined;
+        key?: string | undefined;
+        folder?: string | undefined;
+    }, {
+        url: string;
+        key: string;
+        access: "public" | "private";
+        headers?: Record<string, string> | undefined;
+    }, "mutation", "post", "auth">;
+    "manager.media.finalizeUpload": import("./types").RakunOperationWithInput<{
+        key: string;
+        access?: "public" | "private" | undefined;
+        fileName?: string | undefined;
+        name?: string | undefined;
+        mime?: string | undefined;
+        size?: number | undefined;
+        previewKey?: string | undefined;
+        previewMime?: string | undefined;
+        width?: number | undefined;
+        height?: number | undefined;
+        orientation?: "portrait" | "landscape" | undefined;
+        optimized?: boolean | undefined;
+        optimizedFormat?: string | undefined;
+        optimizationQuality?: number | undefined;
+        originalSize?: number | undefined;
+        folderId?: string | undefined;
+        folderPath?: string | undefined;
+        status?: "uploaded" | "archived" | "deleted" | undefined;
+    }, {
+        key: string;
+        access: "public" | "private";
+        size: number;
+        publicUrl: string | null;
+        media: {
+            _id: string;
+            _type: "Media";
+            name: string;
+            originalName: string;
+            key: string;
+            access: "public" | "private";
+            mime: string;
+            size: number;
+            uploadedAt: Date;
+            status: "uploaded" | "archived" | "deleted";
+            extension?: string | undefined;
+            etag?: string | undefined;
+            url?: string | undefined;
+            previewKey?: string | undefined;
+            previewUrl?: string | undefined;
+            previewMime?: string | undefined;
+            width?: number | undefined;
+            height?: number | undefined;
+            orientation?: "portrait" | "landscape" | undefined;
+            optimized?: boolean | undefined;
+            optimizedFormat?: string | undefined;
+            optimizationQuality?: number | undefined;
+            originalSize?: number | undefined;
+            folder?: {
+                type: "existing";
+                _id: string;
+                contentType: "MediaFolder";
+            } | undefined;
+            createdBy?: string | undefined;
+            updatedBy?: string | undefined;
+            createdAt?: Date | undefined;
+            updatedAt?: Date | undefined;
+        };
+        mime?: string | undefined;
+        etag?: string | undefined;
+        folder?: {
+            _id: string;
+            name: string;
+            slug: string;
+            path: string;
+        } | undefined;
+    }, "mutation", "post", "auth">;
+    "manager.media.getUrl": import("./types").RakunOperationWithInput<{
+        key: string;
+        access?: "public" | "private" | undefined;
+        expiresInSeconds?: number | undefined;
+    }, {
+        key: string;
+        access: "public" | "private";
+        url: string;
+        expiresAt: Date | null;
+        isPublic: boolean;
+    }, "query", "post", "auth">;
+    "manager.media.createFolder": import("./types").RakunOperationWithInput<{
+        name: string;
+        parentId?: string | undefined;
+        description?: string | undefined;
+    }, {
+        _id: string;
+        name: string;
+        slug: string;
+        path: string;
+        parentId?: string | undefined;
+        description?: string | undefined;
+    }, "mutation", "post", "auth">;
+    "manager.media.listFolders": import("./types").RakunOperationWithInput<{
+        parentId?: string | undefined;
+    }, {
+        items: {
+            _id: string;
+            name: string;
+            slug: string;
+            path: string;
+            parentId?: string | undefined;
+            description?: string | undefined;
+        }[];
+    }, "query", "post", "auth">;
+    "manager.literals.list": import("./types").RakunOperationWithInput<{
+        locale?: string | undefined;
+    }, {
+        defaultLocale: string;
+        selectedLocale: string;
+        locales: {
+            code: string;
+            name: string;
+            default: boolean;
+        }[];
+        items: {
+            key: string;
+            defaultMessage: string;
+            description: string;
+            usedBy: string[];
+            variables: {
+                name: string;
+                kind: "argument" | "plural" | "select" | "selectordinal";
+            }[];
+            hasTranslation: boolean;
+            validation: {
+                isValid: boolean;
+                missing: string[];
+                kindMismatch: string[];
+                extra: string[];
+            };
+            translation?: string | undefined;
+        }[];
+    }, "query", "post", "auth">;
+    "manager.literals.upsert": import("./types").RakunOperationWithInput<{
+        key: string;
+        locale: string;
+        message: string;
+    }, {
+        ok: boolean;
+        key: string;
+        locale: string;
+        message: string;
+        validation: {
+            isValid: boolean;
+            missing: string[];
+            kindMismatch: string[];
+            extra: string[];
+        };
+    }, "mutation", "post", "auth">;
+    "manager.auth.updatePassword": import("./types").RakunOperationWithInput<{
+        currentPassword: string;
+        newPassword: string;
+    }, {
+        ok: boolean;
+    }, "mutation", "post", "auth">;
+    "manager.auth.login": import("./types").RakunOperationWithInput<{
+        username: string;
+        password: string;
+    }, {
+        token: string;
+    } | {
+        challenge: string;
+        expiresAt: string;
+        method: string;
+    }, "mutation", "post", "public">;
+    "manager.auth.logout": import("./types").RakunOperationWithoutInput<{
+        token: string;
+    }, "mutation", "post", "auth">;
+    "manager.auth.getSession": import("./types").RakunOperationWithoutInput<{
+        user: string;
+        email: string;
+        role: {
+            name: string;
+            permissions: ("manager.users.readAny" | "manager.users.updateAny" | "manager.users.deleteAny" | "manager.roles.readAny" | "manager.roles.updateAny" | "manager.roles.deleteAny" | "manager.routes.readAny" | "manager.routes.updateAny" | "manager.routes.deleteAny" | "manager.languages.readAny" | "manager.languages.updateAny" | "manager.languages.deleteAny" | "content.Media.readAny" | "content.Media.own" | "content.Media.updateAny" | "content.Media.deleteAny" | "content.Redirect.readAny" | "content.Redirect.own" | "content.Redirect.updateAny" | "content.Redirect.deleteAny" | "manager.literals.readAny" | "manager.literals.updateAny")[];
+            _type: "ManagerRole";
+            _id: string;
+        };
+        twoFactorEnabled: boolean;
+        _type: "ManagerUser";
+        _id: string;
+        password?: undefined;
+    } | null, "query", "get", "public">;
+    "manager.auth.accountInfo": import("./types").RakunOperationWithoutInput<{
+        has2FA: boolean;
+        enabled2FA: boolean;
+        method2FA: "totp" | "webauthn";
+        sessions: {
+            token: string;
+            expiresAt: Date;
+            createdAt?: Date | undefined;
+        }[];
+        currentSession: string;
+    }, "query", "get", "auth">;
+    "manager.auth.deleteSession": import("./types").RakunOperationWithInput<{
+        token: string;
+    }, {
+        ok: boolean;
+    }, "mutation", "post", "auth">;
+    "manager.auth.totp.enroll": import("./types").RakunOperationWithoutInput<{
+        qrDataURL: string;
+        otpauthURL: string;
+    }, "query", "get", "auth">;
+    "manager.auth.totp.confirm": import("./types").RakunOperationWithInput<{
+        code: string;
+    }, {
+        ok: boolean;
+    }, "mutation", "post", "auth">;
+    "manager.auth.totp.verify": import("./types").RakunOperationWithInput<{
+        code: string;
+        challenge: string;
+    }, {
+        token: string;
+    } | {
+        error: string;
+    }, "mutation", "post", "public">;
+    "manager.auth.webauthn.register.options": import("./types").RakunOperationWithInput<{
+        deviceName: string;
+    }, {
+        token: string;
+        options: any;
+    }, "query", "post", "auth">;
+    "manager.auth.webauthn.register.verify": import("./types").RakunOperationWithInput<{
+        token: string;
+        deviceName: string;
+        response: any;
+    }, {
+        ok: boolean;
+    }, "mutation", "post", "auth">;
+    "manager.auth.webauthn.auth.options": import("./types").RakunOperationWithInput<{
+        challengeToken: string;
+    }, {
+        options: any;
+    }, "query", "post", "public">;
+    "manager.auth.webauthn.auth.verify": import("./types").RakunOperationWithInput<{
+        challengeToken: string;
+        response: any;
+    }, {
+        token: string;
+    }, "mutation", "post", "public">;
+} & import("./types").RakunOperationMap;
+export { createManagerOperationDefinitions, createWebOperationDefinitions };
+export { getCustomApiOperationDefinitions, mergeOperationMaps, type RakunOperationNamespace, } from "./custom";
+export { type AnyRakunOperation, type AnyRakunOperationContract, createOperationManifest, createOperationPath, defineOperation, defineOperationContract, mergeOperationContracts, type RakunOperationAccess, type RakunOperationContractDefinition, type RakunOperationContractMap, type RakunOperationDefinitionFromContract, type RakunOperationDefinition, type RakunOperationHttpMethod, type RakunOperationImplementationFromContract, type RakunOperationImplementationMap, type RakunOperationKind, type RakunOperationManifestFromContracts, type RakunOperationMeta, type RakunOperationMap, type RakunOperationSuccessArgs, } from "./types";
+//# sourceMappingURL=index.d.ts.map

package/dist/esm/api/operations/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/api/operations/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,+BAA+B,GAChC,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EAAE,iCAAiC,EAAE,MAAM,WAAW,CAAC;AAC9D,OAAO,EAAE,2BAA2B,EAAE,MAAM,gBAAgB,CAAC;AAC7D,OAAO,EAAE,6BAA6B,EAAE,MAAM,OAAO,CAAC;AAMtD,eAAO,MAAM,+BAA+B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uCAU3C,CAAC;AAEF,OAAO,EAAE,iCAAiC,EAAE,6BAA6B,EAAE,CAAC;AAC5E,OAAO,EACL,gCAAgC,EAChC,kBAAkB,EAClB,KAAK,uBAAuB,GAC7B,MAAM,UAAU,CAAC;AAClB,OAAO,EACL,KAAK,iBAAiB,EACtB,KAAK,yBAAyB,EAC9B,uBAAuB,EACvB,mBAAmB,EACnB,eAAe,EACf,uBAAuB,EACvB,uBAAuB,EACvB,KAAK,oBAAoB,EACzB,KAAK,gCAAgC,EACrC,KAAK,yBAAyB,EAC9B,KAAK,oCAAoC,EACzC,KAAK,wBAAwB,EAC7B,KAAK,wBAAwB,EAC7B,KAAK,wCAAwC,EAC7C,KAAK,+BAA+B,EACpC,KAAK,kBAAkB,EACvB,KAAK,mCAAmC,EACxC,KAAK,kBAAkB,EACvB,KAAK,iBAAiB,EACtB,KAAK,yBAAyB,GAC/B,MAAM,SAAS,CAAC"}

package/dist/esm/api/operations/index.js

@@ -0,0 +1,16 @@
+export { createManagerOperationContracts, } from "./manager-contract";
+import { createManagerOperationDefinitions } from "./manager";
+export { createWebOperationContracts } from "./web-contract";
+import { createWebOperationDefinitions } from "./web";
+import { getCustomApiOperationDefinitions, mergeOperationMaps, } from "./custom";
+export const createRakunOperationDefinitions = () => {
+    const coreOperations = {
+        ...createManagerOperationDefinitions(),
+        ...createWebOperationDefinitions(),
+    };
+    return mergeOperationMaps(coreOperations, getCustomApiOperationDefinitions("unscoped"));
+};
+export { createManagerOperationDefinitions, createWebOperationDefinitions };
+export { getCustomApiOperationDefinitions, mergeOperationMaps, } from "./custom";
+export { createOperationManifest, createOperationPath, defineOperation, defineOperationContract, mergeOperationContracts, } from "./types";
+//# sourceMappingURL=index.js.map

package/dist/esm/api/operations/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/api/operations/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,+BAA+B,GAChC,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EAAE,iCAAiC,EAAE,MAAM,WAAW,CAAC;AAC9D,OAAO,EAAE,2BAA2B,EAAE,MAAM,gBAAgB,CAAC;AAC7D,OAAO,EAAE,6BAA6B,EAAE,MAAM,OAAO,CAAC;AACtD,OAAO,EACL,gCAAgC,EAChC,kBAAkB,GACnB,MAAM,UAAU,CAAC;AAElB,MAAM,CAAC,MAAM,+BAA+B,GAAG,GAAG,EAAE;IAClD,MAAM,cAAc,GAAG;QACrB,GAAG,iCAAiC,EAAE;QACtC,GAAG,6BAA6B,EAAE;KACnC,CAAC;IAEF,OAAO,kBAAkB,CACvB,cAAc,EACd,gCAAgC,CAAC,UAAU,CAAC,CAC7C,CAAC;AACJ,CAAC,CAAC;AAEF,OAAO,EAAE,iCAAiC,EAAE,6BAA6B,EAAE,CAAC;AAC5E,OAAO,EACL,gCAAgC,EAChC,kBAAkB,GAEnB,MAAM,UAAU,CAAC;AAClB,OAAO,EAGL,uBAAuB,EACvB,mBAAmB,EACnB,eAAe,EACf,uBAAuB,EACvB,uBAAuB,GAcxB,MAAM,SAAS,CAAC"}