@rakun-kit/core 1.3.9 → 1.3.11

package/dist/esm/api/operations/web-contract.d.ts

@@ -1,21 +1,21 @@
 export declare const createWebOperationContracts: () => {
-    "web.languages": import("./types.js").RakunOperationContractWithoutInput<{
+    "web.languages": import("./types").RakunOperationContractWithoutInput<{
         code: string;
         name: string;
         default: boolean;
         _type: "Language";
         _id: string;
-        parent?: import("../../index.js").SelfRelationValue<string> | undefined;
+        parent?: import("../..").SelfRelationValue<string> | undefined;
         _schemaVersion?: number | undefined;
-        _visibility?: import("../../index.js").DocumentVisibility | undefined;
-        _visibilityBeforeTrash?: Exclude<import("../../index.js").DocumentVisibility, "trash"> | undefined;
+        _visibility?: import("../..").DocumentVisibility | undefined;
+        _visibilityBeforeTrash?: Exclude<import("../..").DocumentVisibility, "trash"> | undefined;
         _trashed?: boolean | undefined;
         _revision?: number | undefined;
         trashedAt?: Date | undefined;
         createdAt?: Date | undefined;
         updatedAt?: Date | undefined;
     }[], "query", "get", "public">;
-    "web.page": import("./types.js").RakunOperationContractWithInput<{
+    "web.page": import("./types").RakunOperationContractWithInput<{
         path: string;
         search?: string | undefined;
         headers?: Record<string, string> | undefined;
@@ -136,8 +136,8 @@ export declare const createWebOperationContracts: () => {
             } | undefined;
             twitterImageAlt?: string | undefined;
             _schemaVersion?: number | undefined;
-            _visibility?: import("../../index.js").DocumentVisibility | undefined;
-            _visibilityBeforeTrash?: Exclude<import("../../index.js").DocumentVisibility, "trash"> | undefined;
+            _visibility?: import("../..").DocumentVisibility | undefined;
+            _visibilityBeforeTrash?: Exclude<import("../..").DocumentVisibility, "trash"> | undefined;
             _trashed?: boolean | undefined;
             _revision?: number | undefined;
             trashedAt?: Date | undefined;
@@ -147,6 +147,7 @@ export declare const createWebOperationContracts: () => {
             siteName?: string | undefined;
             siteUrl?: string | undefined;
             twitterSite?: string | undefined;
+            alternates?: Record<string, string> | undefined;
         }) | undefined;
         language?: {
             code: string;
@@ -154,10 +155,10 @@ export declare const createWebOperationContracts: () => {
             default: boolean;
             _type: "Language";
             _id: string;
-            parent?: import("../../index.js").SelfRelationValue<string> | undefined;
+            parent?: import("../..").SelfRelationValue<string> | undefined;
             _schemaVersion?: number | undefined;
-            _visibility?: import("../../index.js").DocumentVisibility | undefined;
-            _visibilityBeforeTrash?: Exclude<import("../../index.js").DocumentVisibility, "trash"> | undefined;
+            _visibility?: import("../..").DocumentVisibility | undefined;
+            _visibilityBeforeTrash?: Exclude<import("../..").DocumentVisibility, "trash"> | undefined;
             _trashed?: boolean | undefined;
             _revision?: number | undefined;
             trashedAt?: Date | undefined;
@@ -170,7 +171,7 @@ export declare const createWebOperationContracts: () => {
             status: number;
         } | undefined;
     }, "query", "get", "public">;
-    "web.previewPage": import("./types.js").RakunOperationContractWithInput<{
+    "web.previewPage": import("./types").RakunOperationContractWithInput<{
         token: string;
         path: string;
         search?: string | undefined;
@@ -292,8 +293,8 @@ export declare const createWebOperationContracts: () => {
             } | undefined;
             twitterImageAlt?: string | undefined;
             _schemaVersion?: number | undefined;
-            _visibility?: import("../../index.js").DocumentVisibility | undefined;
-            _visibilityBeforeTrash?: Exclude<import("../../index.js").DocumentVisibility, "trash"> | undefined;
+            _visibility?: import("../..").DocumentVisibility | undefined;
+            _visibilityBeforeTrash?: Exclude<import("../..").DocumentVisibility, "trash"> | undefined;
             _trashed?: boolean | undefined;
             _revision?: number | undefined;
             trashedAt?: Date | undefined;
@@ -303,6 +304,7 @@ export declare const createWebOperationContracts: () => {
             siteName?: string | undefined;
             siteUrl?: string | undefined;
             twitterSite?: string | undefined;
+            alternates?: Record<string, string> | undefined;
         }) | undefined;
         language?: {
             code: string;
@@ -310,10 +312,10 @@ export declare const createWebOperationContracts: () => {
             default: boolean;
             _type: "Language";
             _id: string;
-            parent?: import("../../index.js").SelfRelationValue<string> | undefined;
+            parent?: import("../..").SelfRelationValue<string> | undefined;
             _schemaVersion?: number | undefined;
-            _visibility?: import("../../index.js").DocumentVisibility | undefined;
-            _visibilityBeforeTrash?: Exclude<import("../../index.js").DocumentVisibility, "trash"> | undefined;
+            _visibility?: import("../..").DocumentVisibility | undefined;
+            _visibilityBeforeTrash?: Exclude<import("../..").DocumentVisibility, "trash"> | undefined;
             _trashed?: boolean | undefined;
             _revision?: number | undefined;
             trashedAt?: Date | undefined;
@@ -326,7 +328,7 @@ export declare const createWebOperationContracts: () => {
             status: number;
         } | undefined;
     }, "query", "get", "public">;
-    "web.sitemap": import("./types.js").RakunOperationContractWithInput<{
+    "web.sitemap": import("./types").RakunOperationContractWithInput<{
         language?: string | undefined;
     }, {
         languages: {
@@ -337,10 +339,10 @@ export declare const createWebOperationContracts: () => {
             lastModified?: Date | undefined;
         }[];
     }, "query", "get", "public">;
-    "web.robots": import("./types.js").RakunOperationContractWithoutInput<{
+    "web.robots": import("./types").RakunOperationContractWithoutInput<{
         content: string;
     }, "query", "get", "public">;
-    "web.test": import("./types.js").RakunOperationContractWithoutInput<{
+    "web.test": import("./types").RakunOperationContractWithoutInput<{
         ok: boolean;
     }, "query", "get", "public">;
 };

package/dist/esm/api/operations/web-contract.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"web-contract.d.ts","sourceRoot":"","sources":["../../../../src/api/operations/web-contract.ts"],"names":[],"mappings":"AAeA,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+CA,CAAC"}
+{"version":3,"file":"web-contract.d.ts","sourceRoot":"","sources":["../../../../src/api/operations/web-contract.ts"],"names":[],"mappings":"AAeA,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+CA,CAAC"}

package/dist/esm/api/operations/web-contract.js

@@ -1,7 +1,7 @@
 import z from "zod";
-import { defineOperationContract } from "./types.js";
-import { Language } from "../../internal-content-types/index.js";
-import { pageInput, pageOutput, previewPageInput, previewPageOutput, sitemapInput, sitemapOutput, robotsOutput, } from "../../contracts.js";
+import { defineOperationContract } from "./types";
+import { Language } from "../../internal-content-types";
+import { pageInput, pageOutput, previewPageInput, previewPageOutput, sitemapInput, sitemapOutput, robotsOutput, } from "../../contracts";
 export const createWebOperationContracts = () => ({
     "web.languages": defineOperationContract({
         access: "public",

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

@@ -1,21 +1,21 @@
 export declare const createWebOperationDefinitions: () => {
-    "web.languages": import("./types.js").RakunOperationWithoutInput<{
+    "web.languages": import("./types").RakunOperationWithoutInput<{
         code: string;
         name: string;
         default: boolean;
         _type: "Language";
         _id: string;
-        parent?: import("../../index.js").SelfRelationValue<string> | undefined;
+        parent?: import("../..").SelfRelationValue<string> | undefined;
         _schemaVersion?: number | undefined;
-        _visibility?: import("../../index.js").DocumentVisibility | undefined;
-        _visibilityBeforeTrash?: Exclude<import("../../index.js").DocumentVisibility, "trash"> | undefined;
+        _visibility?: import("../..").DocumentVisibility | undefined;
+        _visibilityBeforeTrash?: Exclude<import("../..").DocumentVisibility, "trash"> | undefined;
         _trashed?: boolean | undefined;
         _revision?: number | undefined;
         trashedAt?: Date | undefined;
         createdAt?: Date | undefined;
         updatedAt?: Date | undefined;
     }[], "query", "get", "public">;
-    "web.page": import("./types.js").RakunOperationWithInput<{
+    "web.page": import("./types").RakunOperationWithInput<{
         path: string;
         search?: string | undefined;
         headers?: Record<string, string> | undefined;
@@ -136,8 +136,8 @@ export declare const createWebOperationDefinitions: () => {
             } | undefined;
             twitterImageAlt?: string | undefined;
             _schemaVersion?: number | undefined;
-            _visibility?: import("../../index.js").DocumentVisibility | undefined;
-            _visibilityBeforeTrash?: Exclude<import("../../index.js").DocumentVisibility, "trash"> | undefined;
+            _visibility?: import("../..").DocumentVisibility | undefined;
+            _visibilityBeforeTrash?: Exclude<import("../..").DocumentVisibility, "trash"> | undefined;
             _trashed?: boolean | undefined;
             _revision?: number | undefined;
             trashedAt?: Date | undefined;
@@ -147,6 +147,7 @@ export declare const createWebOperationDefinitions: () => {
             siteName?: string | undefined;
             siteUrl?: string | undefined;
             twitterSite?: string | undefined;
+            alternates?: Record<string, string> | undefined;
         }) | undefined;
         language?: {
             code: string;
@@ -154,10 +155,10 @@ export declare const createWebOperationDefinitions: () => {
             default: boolean;
             _type: "Language";
             _id: string;
-            parent?: import("../../index.js").SelfRelationValue<string> | undefined;
+            parent?: import("../..").SelfRelationValue<string> | undefined;
             _schemaVersion?: number | undefined;
-            _visibility?: import("../../index.js").DocumentVisibility | undefined;
-            _visibilityBeforeTrash?: Exclude<import("../../index.js").DocumentVisibility, "trash"> | undefined;
+            _visibility?: import("../..").DocumentVisibility | undefined;
+            _visibilityBeforeTrash?: Exclude<import("../..").DocumentVisibility, "trash"> | undefined;
             _trashed?: boolean | undefined;
             _revision?: number | undefined;
             trashedAt?: Date | undefined;
@@ -170,7 +171,7 @@ export declare const createWebOperationDefinitions: () => {
             status: number;
         } | undefined;
     }, "query", "get", "public">;
-    "web.previewPage": import("./types.js").RakunOperationWithInput<{
+    "web.previewPage": import("./types").RakunOperationWithInput<{
         token: string;
         path: string;
         search?: string | undefined;
@@ -292,8 +293,8 @@ export declare const createWebOperationDefinitions: () => {
             } | undefined;
             twitterImageAlt?: string | undefined;
             _schemaVersion?: number | undefined;
-            _visibility?: import("../../index.js").DocumentVisibility | undefined;
-            _visibilityBeforeTrash?: Exclude<import("../../index.js").DocumentVisibility, "trash"> | undefined;
+            _visibility?: import("../..").DocumentVisibility | undefined;
+            _visibilityBeforeTrash?: Exclude<import("../..").DocumentVisibility, "trash"> | undefined;
             _trashed?: boolean | undefined;
             _revision?: number | undefined;
             trashedAt?: Date | undefined;
@@ -303,6 +304,7 @@ export declare const createWebOperationDefinitions: () => {
             siteName?: string | undefined;
             siteUrl?: string | undefined;
             twitterSite?: string | undefined;
+            alternates?: Record<string, string> | undefined;
         }) | undefined;
         language?: {
             code: string;
@@ -310,10 +312,10 @@ export declare const createWebOperationDefinitions: () => {
             default: boolean;
             _type: "Language";
             _id: string;
-            parent?: import("../../index.js").SelfRelationValue<string> | undefined;
+            parent?: import("../..").SelfRelationValue<string> | undefined;
             _schemaVersion?: number | undefined;
-            _visibility?: import("../../index.js").DocumentVisibility | undefined;
-            _visibilityBeforeTrash?: Exclude<import("../../index.js").DocumentVisibility, "trash"> | undefined;
+            _visibility?: import("../..").DocumentVisibility | undefined;
+            _visibilityBeforeTrash?: Exclude<import("../..").DocumentVisibility, "trash"> | undefined;
             _trashed?: boolean | undefined;
             _revision?: number | undefined;
             trashedAt?: Date | undefined;
@@ -326,7 +328,7 @@ export declare const createWebOperationDefinitions: () => {
             status: number;
         } | undefined;
     }, "query", "get", "public">;
-    "web.sitemap": import("./types.js").RakunOperationWithInput<{
+    "web.sitemap": import("./types").RakunOperationWithInput<{
         language?: string | undefined;
     }, {
         languages: {
@@ -337,11 +339,11 @@ export declare const createWebOperationDefinitions: () => {
             lastModified?: Date | undefined;
         }[];
     }, "query", "get", "public">;
-    "web.robots": import("./types.js").RakunOperationWithoutInput<{
+    "web.robots": import("./types").RakunOperationWithoutInput<{
         content: string;
     }, "query", "get", "public">;
-    "web.test": import("./types.js").RakunOperationWithoutInput<{
+    "web.test": import("./types").RakunOperationWithoutInput<{
         ok: boolean;
     }, "query", "get", "public">;
-} & import("./types.js").RakunOperationMap;
+} & import("./types").RakunOperationMap;
 //# sourceMappingURL=web.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"web.d.ts","sourceRoot":"","sources":["../../../../src/api/operations/web.ts"],"names":[],"mappings":"AAsCA,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uCAqCzC,CAAC"}
+{"version":3,"file":"web.d.ts","sourceRoot":"","sources":["../../../../src/api/operations/web.ts"],"names":[],"mappings":"AAsCA,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uCAqCzC,CAAC"}

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

@@ -1,12 +1,12 @@
-import { mergeOperationContracts } from "./types.js";
-import { traceOperationMap } from "./tracing.js";
-import { createWebOperationContracts } from "./web-contract.js";
-import { getCustomApiOperationDefinitions, mergeOperationMaps, } from "./custom.js";
-import { getLanguages } from "../utils/getLanguages.js";
-import { getPage } from "../routes/web/page.js";
-import { getPreviewPage } from "../routes/web/previewPage.js";
-import { getRobots } from "../routes/web/robots.js";
-import { getSitemap } from "../routes/web/sitemap.js";
+import { mergeOperationContracts } from "./types";
+import { traceOperationMap } from "./tracing";
+import { createWebOperationContracts } from "./web-contract";
+import { getCustomApiOperationDefinitions, mergeOperationMaps, } from "./custom";
+import { getLanguages } from "../utils/getLanguages";
+import { getPage } from "../routes/web/page";
+import { getPreviewPage } from "../routes/web/previewPage";
+import { getRobots } from "../routes/web/robots";
+import { getSitemap } from "../routes/web/sitemap";
 const getStringHeaders = (headers) => {
     const values = Object.entries(headers).flatMap(([key, value]) => {
         if (typeof value === "string") {

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

@@ -1,6 +1,6 @@
 import type { z } from "zod";
-import type { FlattenTranslate } from "../../lib/types/index.js";
-import type { RouteDefinition } from "../utils/routes/routeDefinitions.js";
+import type { FlattenTranslate } from "../../lib/types";
+import type { RouteDefinition } from "../utils/routes/routeDefinitions";
 type RouteWithInfo<Routes extends readonly RouteDefinition[]> = Routes[number] extends infer Route ? Route extends {
     infoSchema: z.ZodTypeAny;
 } ? Route : RouteDefinition extends Route ? Route & {

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

@@ -1,5 +1,5 @@
-import ContentType from "../../lib/ContentType.js";
-import { DataInput, DataPopulatedWithoutApiOnly, DataFront, DataPopulated } from "../../lib/types/index.js";
+import ContentType from "../../lib/ContentType";
+import { DataInput, DataPopulatedWithoutApiOnly, DataFront, DataPopulated } from "../../lib/types";
 export type InputProxy<T extends ContentType> = <D extends Partial<DataInput<T>>>(data: D) => D | Promise<D>;
 export type OutputProxy<T extends ContentType> = (data: DataPopulatedWithoutApiOnly<T>) => DataFront<T> | Promise<DataFront<T>>;
 export type ApiProxies = {
@@ -10,10 +10,10 @@ export declare const getInputProxy: (contentTypeName: string) => InputProxy<Cont
 export declare const getOutputProxy: (contentTypeName: string) => OutputProxy<ContentType> | undefined;
 export declare const getProxies: () => {
     input: Record<string, InputProxy<ContentType<{
-        [x: string]: import("../../index.js").AnyField;
+        [x: string]: import("../..").AnyField;
     }, string>>>;
     output: Record<string, OutputProxy<ContentType<{
-        [x: string]: import("../../index.js").AnyField;
+        [x: string]: import("../..").AnyField;
     }, string>>>;
 };
 export declare const ProxyOutput: (item: DataPopulated<ContentType>) => {
@@ -21,8 +21,8 @@ export declare const ProxyOutput: (item: DataPopulated<ContentType>) => {
     _type: string;
     _id: string;
     _schemaVersion?: number | undefined;
-    _visibility?: import("../../index.js").DocumentVisibility | undefined;
-    _visibilityBeforeTrash?: Exclude<import("../../index.js").DocumentVisibility, "trash"> | undefined;
+    _visibility?: import("../..").DocumentVisibility | undefined;
+    _visibilityBeforeTrash?: Exclude<import("../..").DocumentVisibility, "trash"> | undefined;
     _trashed?: boolean | undefined;
     _revision?: number | undefined;
     trashedAt?: Date | undefined;
@@ -34,8 +34,8 @@ export declare const ProxyOutput: (item: DataPopulated<ContentType>) => {
     _type: string;
     _id: string;
     _schemaVersion?: number | undefined;
-    _visibility?: import("../../index.js").DocumentVisibility | undefined;
-    _visibilityBeforeTrash?: Exclude<import("../../index.js").DocumentVisibility, "trash"> | undefined;
+    _visibility?: import("../..").DocumentVisibility | undefined;
+    _visibilityBeforeTrash?: Exclude<import("../..").DocumentVisibility, "trash"> | undefined;
     _trashed?: boolean | undefined;
     _revision?: number | undefined;
     trashedAt?: Date | undefined;

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

@@ -1,4 +1,4 @@
-import { getRakunBootstrapOptions } from "../../bootstrapState.js";
+import { getRakunBootstrapOptions } from "../../bootstrapState";
 export const getInputProxy = (contentTypeName) => {
     return getRakunBootstrapOptions()?.proxies?.input?.[contentTypeName];
 };

package/dist/esm/api/routes/manager/apiOperations.d.ts

@@ -1,6 +1,6 @@
-import type { ApiOperationsOutput } from "../../../schemas/manager/apiOperations.js";
-import type { RakunRequestContext } from "../../context.js";
-import type { RakunOperationContractMap, RakunOperationImplementationMap } from "../../operations/types.js";
+import type { ApiOperationsOutput } from "../../../schemas/manager/apiOperations";
+import type { RakunRequestContext } from "../../context";
+import type { RakunOperationContractMap, RakunOperationImplementationMap } from "../../operations/types";
 export declare const apiOperationsHandler: <TContracts extends RakunOperationContractMap>({ contracts, implementations, ctx, }: {
     contracts: TContracts;
     implementations: RakunOperationImplementationMap<TContracts>;

package/dist/esm/api/routes/manager/apiOperations.js

@@ -1,8 +1,8 @@
-import { createApiOperationCatalog } from "../../operations/catalog.js";
-import { getCustomApiOperationDefinitions, mergeOperationMaps, } from "../../operations/custom.js";
-import { mergeOperationContracts } from "../../operations/types.js";
-import { createWebOperationDefinitions } from "../../operations/web.js";
-import { checkPermissions } from "../../utils/checkPermissions.js";
+import { createApiOperationCatalog } from "../../operations/catalog";
+import { getCustomApiOperationDefinitions, mergeOperationMaps, } from "../../operations/custom";
+import { mergeOperationContracts } from "../../operations/types";
+import { createWebOperationDefinitions } from "../../operations/web";
+import { checkPermissions } from "../../utils/checkPermissions";
 export const apiOperationsHandler = async ({ contracts, implementations, ctx, }) => {
     const user = ctx.getUser();
     checkPermissions(user, ["manager.apiOperations.readAny"]);

package/dist/esm/api/routes/manager/auth/accountInfo.d.ts

@@ -1,5 +1,5 @@
-import { RakunRequestContext } from "../../../context.js";
-import { AccountInfoOutput } from "../../../../schemas/manager/auth/accountInfo.js";
+import { RakunRequestContext } from "../../../context";
+import { AccountInfoOutput } from "../../../../schemas/manager/auth/accountInfo";
 export declare const accountInfoHandler: ({ ctx, }: {
     ctx: RakunRequestContext;
 }) => Promise<AccountInfoOutput>;

package/dist/esm/api/routes/manager/auth/accountInfo.js

@@ -1,6 +1,6 @@
-import { Session, UserMfa } from "../../../../internal-content-types/index.js";
-import { getMongoService } from "../../../../orm/index.js";
-import { getSessionCookie } from "../../../sessionCookie.js";
+import { Session, UserMfa } from "../../../../internal-content-types";
+import { getMongoService } from "../../../../orm";
+import { getSessionCookie } from "../../../sessionCookie";
 export const accountInfoHandler = async ({ ctx, }) => {
     const user = ctx.getUser();
     const db = await getMongoService();

package/dist/esm/api/routes/manager/auth/deleteSession.d.ts

@@ -1,5 +1,5 @@
-import { RakunRequestContext } from "../../../context.js";
-import { DeleteSessionInput } from "../../../../schemas/manager/auth/deleteSession.js";
+import { RakunRequestContext } from "../../../context";
+import { DeleteSessionInput } from "../../../../schemas/manager/auth/deleteSession";
 export declare const deleteSessionHandler: ({ input, ctx, }: {
     input: DeleteSessionInput;
     ctx: RakunRequestContext;

package/dist/esm/api/routes/manager/auth/deleteSession.js

@@ -1,6 +1,6 @@
-import { Session } from "../../../../internal-content-types/index.js";
-import { throwAppError } from "../../../../lib/errors/index.js";
-import { getMongoService } from "../../../../orm/index.js";
+import { Session } from "../../../../internal-content-types";
+import { throwAppError } from "../../../../lib/errors";
+import { getMongoService } from "../../../../orm";
 export const deleteSessionHandler = async ({ input, ctx, }) => {
     const user = ctx.getUser();
     const db = await getMongoService();

package/dist/esm/api/routes/manager/auth/getSession.d.ts

@@ -1,4 +1,4 @@
-import { RakunRequestContext } from "../../../context.js";
+import { RakunRequestContext } from "../../../context";
 export declare const getSessionHandler: ({ ctx, }: {
     ctx: RakunRequestContext;
 }) => Promise<{
@@ -10,8 +10,8 @@ export declare const getSessionHandler: ({ ctx, }: {
         _type: "ManagerRole";
         _id: string;
         _schemaVersion?: number | undefined;
-        _visibility?: import("../../../../index.js").DocumentVisibility | undefined;
-        _visibilityBeforeTrash?: Exclude<import("../../../../index.js").DocumentVisibility, "trash"> | undefined;
+        _visibility?: import("../../../..").DocumentVisibility | undefined;
+        _visibilityBeforeTrash?: Exclude<import("../../../..").DocumentVisibility, "trash"> | undefined;
         _trashed?: boolean | undefined;
         _revision?: number | undefined;
         trashedAt?: Date | undefined;
@@ -30,8 +30,8 @@ export declare const getSessionHandler: ({ ctx, }: {
     tutorialsPromptedAt?: Date | undefined;
     seenTours?: (string | undefined)[] | undefined;
     _schemaVersion?: number | undefined;
-    _visibility?: import("../../../../index.js").DocumentVisibility | undefined;
-    _visibilityBeforeTrash?: Exclude<import("../../../../index.js").DocumentVisibility, "trash"> | undefined;
+    _visibility?: import("../../../..").DocumentVisibility | undefined;
+    _visibilityBeforeTrash?: Exclude<import("../../../..").DocumentVisibility, "trash"> | undefined;
     _trashed?: boolean | undefined;
     _revision?: number | undefined;
     trashedAt?: Date | undefined;

package/dist/esm/api/routes/manager/auth/login.d.ts

@@ -1,4 +1,4 @@
-import { LoginInput, LoginOutput } from "../../../../schemas/manager/auth/login.js";
+import { LoginInput, LoginOutput } from "../../../../schemas/manager/auth/login";
 export declare const loginHandler: ({ input, }: {
     input: LoginInput;
 }) => Promise<LoginOutput>;

package/dist/esm/api/routes/manager/auth/login.js

@@ -1,8 +1,8 @@
 import { randomBytes } from "crypto";
-import { ManagerUser, UserMfa, MfaChallenge, Session, } from "../../../../internal-content-types/index.js";
-import { throwAppError } from "../../../../lib/errors/index.js";
-import { getMongoService } from "../../../../orm/index.js";
-import { verifyPassword } from "../../../utils/passwords.js";
+import { ManagerUser, UserMfa, MfaChallenge, Session, } from "../../../../internal-content-types";
+import { throwAppError } from "../../../../lib/errors";
+import { getMongoService } from "../../../../orm";
+import { verifyPassword } from "../../../utils/passwords";
 export const loginHandler = async ({ input, }) => {
     const { username, password } = input;
     const db = await getMongoService();

package/dist/esm/api/routes/manager/auth/logout.d.ts

@@ -1,4 +1,4 @@
-import { RakunRequestContext } from "../../../context.js";
+import { RakunRequestContext } from "../../../context";
 export declare const logoutHandler: ({ ctx }: {
     ctx: RakunRequestContext;
 }) => Promise<{

package/dist/esm/api/routes/manager/auth/logout.js

@@ -1,6 +1,6 @@
-import { Session } from "../../../../internal-content-types/index.js";
-import { getMongoService } from "../../../../orm/index.js";
-import { getSessionCookie } from "../../../sessionCookie.js";
+import { Session } from "../../../../internal-content-types";
+import { getMongoService } from "../../../../orm";
+import { getSessionCookie } from "../../../sessionCookie";
 const emptyToken = { token: "" };
 export const logoutHandler = async ({ ctx }) => {
     if (!ctx?.req?.cookies)

package/dist/esm/api/routes/manager/auth/markTourSeen.d.ts

@@ -1,5 +1,5 @@
-import type { MarkTourSeenInput } from "../../../../schemas/manager/auth/tutorials.js";
-import { RakunRequestContext } from "../../../context.js";
+import type { MarkTourSeenInput } from "../../../../schemas/manager/auth/tutorials";
+import { RakunRequestContext } from "../../../context";
 export declare const markTourSeenHandler: ({ input, ctx, }: {
     input: MarkTourSeenInput;
     ctx: RakunRequestContext;
@@ -13,8 +13,8 @@ export declare const markTourSeenHandler: ({ input, ctx, }: {
         _type: "ManagerRole";
         _id: string;
         _schemaVersion?: number | undefined;
-        _visibility?: import("../../../../index.js").DocumentVisibility | undefined;
-        _visibilityBeforeTrash?: Exclude<import("../../../../index.js").DocumentVisibility, "trash"> | undefined;
+        _visibility?: import("../../../..").DocumentVisibility | undefined;
+        _visibilityBeforeTrash?: Exclude<import("../../../..").DocumentVisibility, "trash"> | undefined;
         _trashed?: boolean | undefined;
         _revision?: number | undefined;
         trashedAt?: Date | undefined;
@@ -36,8 +36,8 @@ export declare const markTourSeenHandler: ({ input, ctx, }: {
     tutorialsPromptedAt?: Date | undefined;
     seenTours?: (string | undefined)[] | undefined;
     _schemaVersion?: number | undefined;
-    _visibility?: import("../../../../index.js").DocumentVisibility | undefined;
-    _visibilityBeforeTrash?: Exclude<import("../../../../index.js").DocumentVisibility, "trash"> | undefined;
+    _visibility?: import("../../../..").DocumentVisibility | undefined;
+    _visibilityBeforeTrash?: Exclude<import("../../../..").DocumentVisibility, "trash"> | undefined;
     _trashed?: boolean | undefined;
     _revision?: number | undefined;
     trashedAt?: Date | undefined;

package/dist/esm/api/routes/manager/auth/markTourSeen.js

@@ -1,6 +1,6 @@
-import { ManagerUser } from "../../../../internal-content-types/index.js";
-import { getMongoService } from "../../../../orm/index.js";
-import { populateRelations } from "../../../utils/populates/populateRelations.js";
+import { ManagerUser } from "../../../../internal-content-types";
+import { getMongoService } from "../../../../orm";
+import { populateRelations } from "../../../utils/populates/populateRelations";
 export const markTourSeenHandler = async ({ input, ctx, }) => {
     const user = ctx.getUser();
     const db = await getMongoService();

package/dist/esm/api/routes/manager/auth/totp/confirmTotp.d.ts

@@ -1,5 +1,5 @@
-import { RakunRequestContext } from "../../../../context.js";
-import { ConfirmTotpInput } from "../../../../../schemas/manager/auth/totp/confirmTotp.js";
+import { RakunRequestContext } from "../../../../context";
+import { ConfirmTotpInput } from "../../../../../schemas/manager/auth/totp/confirmTotp";
 export declare const confirmTotpHandler: ({ input, ctx, }: {
     input: ConfirmTotpInput;
     ctx: RakunRequestContext;

package/dist/esm/api/routes/manager/auth/totp/confirmTotp.js

@@ -1,5 +1,5 @@
-import { UserMfa, ManagerUser } from "../../../../../internal-content-types/index.js";
-import { getMongoService } from "../../../../../orm/index.js";
+import { UserMfa, ManagerUser } from "../../../../../internal-content-types";
+import { getMongoService } from "../../../../../orm";
 import * as OTPAuth from "otpauth";
 export const confirmTotpHandler = async ({ input, ctx, }) => {
     const db = await getMongoService();

package/dist/esm/api/routes/manager/auth/totp/enrollTotp.d.ts

@@ -1,4 +1,4 @@
-import { RakunRequestContext } from "../../../../context.js";
+import { RakunRequestContext } from "../../../../context";
 export declare const enrollTotpHandler: ({ ctx, }: {
     ctx: RakunRequestContext;
 }) => Promise<{

package/dist/esm/api/routes/manager/auth/totp/enrollTotp.js

@@ -1,9 +1,9 @@
 import { randomBytes } from "crypto";
 import * as OTPAuth from "otpauth";
 import QRCode from "qrcode";
-import { UserMfa, ManagerUser } from "../../../../../internal-content-types/index.js";
-import { throwAppError } from "../../../../../lib/errors/index.js";
-import { getMongoService } from "../../../../../orm/index.js";
+import { UserMfa, ManagerUser } from "../../../../../internal-content-types";
+import { throwAppError } from "../../../../../lib/errors";
+import { getMongoService } from "../../../../../orm";
 export const enrollTotpHandler = async ({ ctx, }) => {
     const db = await getMongoService();
     const user = ctx.getUser();

package/dist/esm/api/routes/manager/auth/totp/verifyTotp.d.ts

@@ -1,4 +1,4 @@
-import { VerifyTotpInput } from "../../../../../schemas/manager/auth/totp/verifyTotp.js";
+import { VerifyTotpInput } from "../../../../../schemas/manager/auth/totp/verifyTotp";
 export declare const verifyTotpHandler: ({ input, }: {
     input: VerifyTotpInput;
 }) => Promise<{

package/dist/esm/api/routes/manager/auth/totp/verifyTotp.js

@@ -1,7 +1,7 @@
 import * as OTPAuth from "otpauth";
-import { MfaChallenge, ManagerUser, UserMfa, Session, } from "../../../../../internal-content-types/index.js";
-import { throwAppError } from "../../../../../lib/errors/index.js";
-import { getMongoService } from "../../../../../orm/index.js";
+import { MfaChallenge, ManagerUser, UserMfa, Session, } from "../../../../../internal-content-types";
+import { throwAppError } from "../../../../../lib/errors";
+import { getMongoService } from "../../../../../orm";
 export const verifyTotpHandler = async ({ input, }) => {
     const db = await getMongoService();
     const { challenge, code } = input;