@rakun-kit/core 1.7.3 → 1.7.4

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

@@ -1,24 +1,24 @@
 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;
         _localeVariantGroupId?: string | undefined;
         _localeVariantName?: string | undefined;
-        _localeVariantRole?: import("zod").infer<typeof import("../../index.js").LocaleVariantRole> | undefined;
+        _localeVariantRole?: import("zod").infer<typeof import("../..").LocaleVariantRole> | 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;
@@ -60,6 +60,7 @@ export declare const createWebOperationDefinitions: () => {
                 key?: string | undefined;
                 access?: "public" | "private" | undefined;
                 previewKey?: string | null | undefined;
+                posterUrl?: string | null | undefined;
                 title?: string | undefined;
                 alt?: string | null | undefined;
                 sizes?: {
@@ -98,6 +99,7 @@ export declare const createWebOperationDefinitions: () => {
                 key?: string | undefined;
                 access?: "public" | "private" | undefined;
                 previewKey?: string | null | undefined;
+                posterUrl?: string | null | undefined;
                 title?: string | undefined;
                 alt?: string | null | undefined;
                 sizes?: {
@@ -133,6 +135,7 @@ export declare const createWebOperationDefinitions: () => {
                 key?: string | undefined;
                 access?: "public" | "private" | undefined;
                 previewKey?: string | null | undefined;
+                posterUrl?: string | null | undefined;
                 title?: string | undefined;
                 alt?: string | null | undefined;
                 sizes?: {
@@ -153,13 +156,13 @@ 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;
             _localeVariantGroupId?: string | undefined;
             _localeVariantName?: string | undefined;
-            _localeVariantRole?: import("zod").infer<typeof import("../../index.js").LocaleVariantRole> | undefined;
+            _localeVariantRole?: import("zod").infer<typeof import("../..").LocaleVariantRole> | undefined;
             trashedAt?: Date | undefined;
             createdAt?: Date | undefined;
             updatedAt?: Date | undefined;
@@ -175,15 +178,15 @@ 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;
             _localeVariantGroupId?: string | undefined;
             _localeVariantName?: string | undefined;
-            _localeVariantRole?: import("zod").infer<typeof import("../../index.js").LocaleVariantRole> | undefined;
+            _localeVariantRole?: import("zod").infer<typeof import("../..").LocaleVariantRole> | undefined;
             trashedAt?: Date | undefined;
             createdAt?: Date | undefined;
             updatedAt?: Date | undefined;
@@ -195,7 +198,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;
@@ -238,6 +241,7 @@ export declare const createWebOperationDefinitions: () => {
                 key?: string | undefined;
                 access?: "public" | "private" | undefined;
                 previewKey?: string | null | undefined;
+                posterUrl?: string | null | undefined;
                 title?: string | undefined;
                 alt?: string | null | undefined;
                 sizes?: {
@@ -276,6 +280,7 @@ export declare const createWebOperationDefinitions: () => {
                 key?: string | undefined;
                 access?: "public" | "private" | undefined;
                 previewKey?: string | null | undefined;
+                posterUrl?: string | null | undefined;
                 title?: string | undefined;
                 alt?: string | null | undefined;
                 sizes?: {
@@ -311,6 +316,7 @@ export declare const createWebOperationDefinitions: () => {
                 key?: string | undefined;
                 access?: "public" | "private" | undefined;
                 previewKey?: string | null | undefined;
+                posterUrl?: string | null | undefined;
                 title?: string | undefined;
                 alt?: string | null | undefined;
                 sizes?: {
@@ -331,13 +337,13 @@ 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;
             _localeVariantGroupId?: string | undefined;
             _localeVariantName?: string | undefined;
-            _localeVariantRole?: import("zod").infer<typeof import("../../index.js").LocaleVariantRole> | undefined;
+            _localeVariantRole?: import("zod").infer<typeof import("../..").LocaleVariantRole> | undefined;
             trashedAt?: Date | undefined;
             createdAt?: Date | undefined;
             updatedAt?: Date | undefined;
@@ -353,15 +359,15 @@ 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;
             _localeVariantGroupId?: string | undefined;
             _localeVariantName?: string | undefined;
-            _localeVariantRole?: import("zod").infer<typeof import("../../index.js").LocaleVariantRole> | undefined;
+            _localeVariantRole?: import("zod").infer<typeof import("../..").LocaleVariantRole> | undefined;
             trashedAt?: Date | undefined;
             createdAt?: Date | undefined;
             updatedAt?: Date | undefined;
@@ -373,7 +379,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: {
@@ -384,23 +390,23 @@ export declare const createWebOperationDefinitions: () => {
             lastModified?: Date | undefined;
         }[];
     }, "query", "get", "public">;
-    'web.staticPaths': import("./types.js").RakunOperationWithoutInput<{
+    'web.staticPaths': import("./types").RakunOperationWithoutInput<{
         items: {
             path: string;
             ttl: number;
         }[];
     }, "query", "get", "public">;
-    'web.robots': import("./types.js").RakunOperationWithoutInput<{
+    'web.robots': import("./types").RakunOperationWithoutInput<{
         content: string;
     }, "query", "get", "public">;
-    'web.llms': import("./types.js").RakunOperationWithInput<{
+    'web.llms': import("./types").RakunOperationWithInput<{
         language?: string | undefined;
     }, {
         content: string;
         language: string;
     } | null, "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":"AAmCA,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uCA2CzC,CAAA"}
+{"version":3,"file":"web.d.ts","sourceRoot":"","sources":["../../../../src/api/operations/web.ts"],"names":[],"mappings":"AAmCA,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uCA2CzC,CAAA"}

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

@@ -1,14 +1,14 @@
-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 { getLlmsTxt } from '../routes/web/llms.js';
-import { getSitemap } from '../routes/web/sitemap.js';
-import { getStaticPaths } from '../routes/web/staticPaths.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 { getLlmsTxt } from '../routes/web/llms';
+import { getSitemap } from '../routes/web/sitemap';
+import { getStaticPaths } from '../routes/web/staticPaths';
 const getStringHeaders = (headers) => {
     const values = Object.entries(headers).flatMap(([key, value]) => {
         if (typeof value === 'string') {

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

@@ -1,5 +1,5 @@
-import { type RealtimeSubscriptionLifecycle } from '../platform/index.js';
-import type { RakunRequestContext } from './context.js';
+import { type RealtimeSubscriptionLifecycle } from '../platform';
+import type { RakunRequestContext } from './context';
 export type RealtimeSubscriptionAuthorization = {
     ok: true;
     topics: string[];

package/dist/esm/api/realtime.js

@@ -1,10 +1,10 @@
-import { getCollaborationRoomReferenceFromTopic, getCollaborationService, } from '../collaboration/index.js';
-import { throwAppError, getAppErrorStatusCode } from '../lib/errors/index.js';
-import { getPlatform, parseRealtimePresenceBindings, parseRealtimeTopics, } from '../platform/index.js';
-import { recordApiError } from './operations/index.js';
-import { requireTemplateUpdate } from './routes/manager/template.js';
-import { checkOwnership } from './utils/checkOwnership.js';
-import { requireContentType } from './utils/requireContentType.js';
+import { getCollaborationRoomReferenceFromTopic, getCollaborationService, } from '../collaboration';
+import { throwAppError, getAppErrorStatusCode } from '../lib/errors';
+import { getPlatform, parseRealtimePresenceBindings, parseRealtimeTopics, } from '../platform';
+import { recordApiError } from './operations';
+import { requireTemplateUpdate } from './routes/manager/template';
+import { checkOwnership } from './utils/checkOwnership';
+import { requireContentType } from './utils/requireContentType';
 const rejectRealtimeSubscription = async ({ ctx, message, status, }) => {
     await recordApiError({
         name: 'manager.realtime.subscribe',

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, ["content.ApiOperation.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/externalLogin.d.ts

@@ -1,5 +1,5 @@
-import type { ExternalLoginCompleteInput, ExternalLoginCompleteOutput, ExternalLoginStartInput, ExternalLoginStartOutput } from '../../../../schemas/manager/auth/externalLogin.js';
-import type { RakunRequestContext } from '../../../context.js';
+import type { ExternalLoginCompleteInput, ExternalLoginCompleteOutput, ExternalLoginStartInput, ExternalLoginStartOutput } from '../../../../schemas/manager/auth/externalLogin';
+import type { RakunRequestContext } from '../../../context';
 export declare const externalLoginStartHandler: ({ input, ctx, }: {
     input: ExternalLoginStartInput;
     ctx?: RakunRequestContext;

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

@@ -1,11 +1,11 @@
-import { completePrimaryAuthentication } from '../../../../auth/completePrimaryAuthentication.js';
-import { getRakunBootstrapOptions } from '../../../../bootstrapState.js';
-import { ManagerUser } from '../../../../internal-content-types/index.js';
-import { throwAppError } from '../../../../lib/errors/index.js';
-import { getMongoService } from '../../../../orm/index.js';
-import { recordAuthEvent } from '../../../utils/authEvents.js';
-import { assertAuthRateLimit, getRequestRateLimitIdentifier, resetAuthRateLimit, } from '../../../utils/authRateLimit.js';
-import { getPlatform } from '../../../../platform/index.js';
+import { completePrimaryAuthentication } from '../../../../auth/completePrimaryAuthentication';
+import { getRakunBootstrapOptions } from '../../../../bootstrapState';
+import { ManagerUser } from '../../../../internal-content-types';
+import { throwAppError } from '../../../../lib/errors';
+import { getMongoService } from '../../../../orm';
+import { recordAuthEvent } from '../../../utils/authEvents';
+import { assertAuthRateLimit, getRequestRateLimitIdentifier, resetAuthRateLimit, } from '../../../utils/authRateLimit';
+import { getPlatform } from '../../../../platform';
 const LOGIN_FLOW_COOKIE = 'rakun_login_flow';
 const LOGIN_FLOW_MAX_AGE_MS = 10 * 60 * 1000;
 const getAdapter = (provider) => {

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,13 +10,13 @@ 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;
         _localeVariantGroupId?: string | undefined;
         _localeVariantName?: string | undefined;
-        _localeVariantRole?: import("zod").infer<typeof import("../../../../index.js").LocaleVariantRole> | undefined;
+        _localeVariantRole?: import("zod").infer<typeof import("../../../..").LocaleVariantRole> | undefined;
         trashedAt?: Date | undefined;
         createdAt?: Date | undefined;
         updatedAt?: Date | undefined;
@@ -34,13 +34,13 @@ export declare const getSessionHandler: ({ ctx, }: {
     tutorialsPromptedAt?: Date | undefined;
     seenTours?: 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;
     _localeVariantGroupId?: string | undefined;
     _localeVariantName?: string | undefined;
-    _localeVariantRole?: import("zod").infer<typeof import("../../../../index.js").LocaleVariantRole> | undefined;
+    _localeVariantRole?: import("zod").infer<typeof import("../../../..").LocaleVariantRole> | undefined;
     trashedAt?: Date | undefined;
     createdAt?: Date | undefined;
     updatedAt?: Date | undefined;

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

@@ -1,5 +1,5 @@
-import { LoginInput, LoginOutput } from "../../../../schemas/manager/auth/login.js";
-import type { RakunRequestContext } from "../../../context.js";
+import { LoginInput, LoginOutput } from "../../../../schemas/manager/auth/login";
+import type { RakunRequestContext } from "../../../context";
 export declare const loginHandler: ({ input, ctx, }: {
     input: LoginInput;
     ctx?: RakunRequestContext;

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

@@ -1,12 +1,12 @@
-import { completePrimaryAuthentication } from "../../../../auth/completePrimaryAuthentication.js";
-import { clearPasswordFailures, getBlockedPasswordIp, recordPasswordFailure, resolvePasswordLoginIp, } from '../../../../auth/passwordFail2ban.js';
-import { getRakunBootstrapOptions } from "../../../../bootstrapState.js";
-import { LoginIpBlock, ManagerUser } from "../../../../internal-content-types/index.js";
-import { throwAppError } from "../../../../lib/errors/index.js";
-import { getMongoService } from "../../../../orm/index.js";
-import { recordAuthEvent } from '../../../utils/authEvents.js';
-import { setApiErrorEventData } from '../../../operations/apiEventLog.js';
-import { hashPassword, verifyStoredPassword } from "../../../utils/passwords.js";
+import { completePrimaryAuthentication } from "../../../../auth/completePrimaryAuthentication";
+import { clearPasswordFailures, getBlockedPasswordIp, recordPasswordFailure, resolvePasswordLoginIp, } from '../../../../auth/passwordFail2ban';
+import { getRakunBootstrapOptions } from "../../../../bootstrapState";
+import { LoginIpBlock, ManagerUser } from "../../../../internal-content-types";
+import { throwAppError } from "../../../../lib/errors";
+import { getMongoService } from "../../../../orm";
+import { recordAuthEvent } from '../../../utils/authEvents';
+import { setApiErrorEventData } from '../../../operations/apiEventLog';
+import { hashPassword, verifyStoredPassword } from "../../../utils/passwords";
 export const loginHandler = async ({ input, ctx, }) => {
     if (getRakunBootstrapOptions()?.login?.password === false) {
         throwAppError("FORBIDDEN", { reason: "LOGIN_METHOD_DISABLED" });

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,13 +13,13 @@ 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;
         _localeVariantGroupId?: string | undefined;
         _localeVariantName?: string | undefined;
-        _localeVariantRole?: import("zod").infer<typeof import("../../../../index.js").LocaleVariantRole> | undefined;
+        _localeVariantRole?: import("zod").infer<typeof import("../../../..").LocaleVariantRole> | undefined;
         trashedAt?: Date | undefined;
         trashedBy?: string | undefined;
         createdAt?: Date | undefined;
@@ -40,13 +40,13 @@ export declare const markTourSeenHandler: ({ input, ctx, }: {
     tutorialsPromptedAt?: Date | undefined;
     seenTours?: 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;
     _localeVariantGroupId?: string | undefined;
     _localeVariantName?: string | undefined;
-    _localeVariantRole?: import("zod").infer<typeof import("../../../../index.js").LocaleVariantRole> | undefined;
+    _localeVariantRole?: import("zod").infer<typeof import("../../../..").LocaleVariantRole> | undefined;
     trashedAt?: Date | undefined;
     trashedBy?: string | undefined;
     createdAt?: 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/mfa/regenerateRecoveryCodes.d.ts

@@ -1,5 +1,5 @@
-import type { RegenerateRecoveryCodesInput } from '../../../../../schemas/manager/auth/mfa/recoveryCode.js';
-import type { RakunRequestContext } from '../../../../context.js';
+import type { RegenerateRecoveryCodesInput } from '../../../../../schemas/manager/auth/mfa/recoveryCode';
+import type { RakunRequestContext } from '../../../../context';
 export declare const regenerateRecoveryCodesHandler: ({ input, ctx, }: {
     input: RegenerateRecoveryCodesInput;
     ctx: RakunRequestContext;

package/dist/esm/api/routes/manager/auth/mfa/regenerateRecoveryCodes.js

@@ -1,9 +1,9 @@
-import { ManagerUser, UserMfa, } from '../../../../../internal-content-types/index.js';
-import { throwAppError } from '../../../../../lib/errors/index.js';
-import { getMongoService } from '../../../../../orm/index.js';
-import { verifyStoredPassword } from '../../../../utils/passwords.js';
-import { generateRecoveryCodes } from '../../../../utils/recoveryCodes.js';
-import { recordAuthEvent } from '../../../../utils/authEvents.js';
+import { ManagerUser, UserMfa, } from '../../../../../internal-content-types';
+import { throwAppError } from '../../../../../lib/errors';
+import { getMongoService } from '../../../../../orm';
+import { verifyStoredPassword } from '../../../../utils/passwords';
+import { generateRecoveryCodes } from '../../../../utils/recoveryCodes';
+import { recordAuthEvent } from '../../../../utils/authEvents';
 export const regenerateRecoveryCodesHandler = async ({ input, ctx, }) => {
     const db = await getMongoService();
     const user = ctx.getUser();

package/dist/esm/api/routes/manager/auth/mfa/verifyRecoveryCode.d.ts

@@ -1,5 +1,5 @@
-import type { VerifyRecoveryCodeInput } from '../../../../../schemas/manager/auth/mfa/recoveryCode.js';
-import type { RakunRequestContext } from '../../../../context.js';
+import type { VerifyRecoveryCodeInput } from '../../../../../schemas/manager/auth/mfa/recoveryCode';
+import type { RakunRequestContext } from '../../../../context';
 export declare const verifyRecoveryCodeHandler: ({ input, ctx, }: {
     input: VerifyRecoveryCodeInput;
     ctx?: RakunRequestContext;

package/dist/esm/api/routes/manager/auth/mfa/verifyRecoveryCode.js

@@ -1,11 +1,11 @@
-import { ManagerUser, MfaChallenge, Session, UserMfa, } from '../../../../../internal-content-types/index.js';
-import { throwAppError } from '../../../../../lib/errors/index.js';
-import { getMongoService } from '../../../../../orm/index.js';
-import { SESSION_MAX_AGE_MS } from '../../../../sessionCookie.js';
-import { assertAuthRateLimit, resetAuthRateLimit, } from '../../../../utils/authRateLimit.js';
-import { findRecoveryCodeHash } from '../../../../utils/recoveryCodes.js';
-import { recordAuthEvent } from '../../../../utils/authEvents.js';
-import { getPlatform } from '../../../../../platform/index.js';
+import { ManagerUser, MfaChallenge, Session, UserMfa, } from '../../../../../internal-content-types';
+import { throwAppError } from '../../../../../lib/errors';
+import { getMongoService } from '../../../../../orm';
+import { SESSION_MAX_AGE_MS } from '../../../../sessionCookie';
+import { assertAuthRateLimit, resetAuthRateLimit, } from '../../../../utils/authRateLimit';
+import { findRecoveryCodeHash } from '../../../../utils/recoveryCodes';
+import { recordAuthEvent } from '../../../../utils/authEvents';
+import { getPlatform } from '../../../../../platform';
 export const verifyRecoveryCodeHandler = async ({ input, ctx, }) => {
     const db = await getMongoService();
     const rateLimitKey = `mfa:recovery:${input.challenge}`;

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

@@ -1,5 +1,5 @@
-import type { ListPasswordIpBlocksOutput, UnblockPasswordIpInput, UnblockPasswordIpOutput } from '../../../../schemas/manager/auth/passwordIpBlocks.js';
-import type { RakunRequestContext } from '../../../context.js';
+import type { ListPasswordIpBlocksOutput, UnblockPasswordIpInput, UnblockPasswordIpOutput } from '../../../../schemas/manager/auth/passwordIpBlocks';
+import type { RakunRequestContext } from '../../../context';
 export declare const listPasswordIpBlocksHandler: ({ ctx, }: {
     ctx: RakunRequestContext;
 }) => Promise<ListPasswordIpBlocksOutput>;

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

@@ -1,11 +1,11 @@
-import { getPasswordFail2banConfig } from '../../../../auth/passwordFail2ban.js';
-import { LoginIpBlock } from '../../../../internal-content-types/index.js';
-import { getEventLogService } from '../../../../eventLog/index.js';
-import { throwAppError } from '../../../../lib/errors/index.js';
-import { AUTH_IP_BLOCK_MANAGE_PERMISSION } from '../../../../lib/Permissions.js';
-import { getMongoService } from '../../../../orm/index.js';
-import { recordAuthEvent } from '../../../utils/authEvents.js';
-import { checkPermissions } from '../../../utils/checkPermissions.js';
+import { getPasswordFail2banConfig } from '../../../../auth/passwordFail2ban';
+import { LoginIpBlock } from '../../../../internal-content-types';
+import { getEventLogService } from '../../../../eventLog';
+import { throwAppError } from '../../../../lib/errors';
+import { AUTH_IP_BLOCK_MANAGE_PERMISSION } from '../../../../lib/Permissions';
+import { getMongoService } from '../../../../orm';
+import { recordAuthEvent } from '../../../utils/authEvents';
+import { checkPermissions } from '../../../utils/checkPermissions';
 const requireManagePermission = (ctx) => {
     const user = ctx.getUser();
     checkPermissions(user, [AUTH_IP_BLOCK_MANAGE_PERMISSION]);

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

@@ -1,5 +1,5 @@
-import type { RequestPasswordResetInput, ResetPasswordInput } from '../../../../schemas/manager/auth/passwordRecovery.js';
-import type { RakunRequestContext } from '../../../context.js';
+import type { RequestPasswordResetInput, ResetPasswordInput } from '../../../../schemas/manager/auth/passwordRecovery';
+import type { RakunRequestContext } from '../../../context';
 export declare const requestPasswordResetHandler: ({ input, ctx, }: {
     input: RequestPasswordResetInput;
     ctx?: RakunRequestContext;