@archiva/archiva-nextjs 0.2.94 → 0.3.1

package/dist/chunk-5ZJUGBTU.mjs

@@ -0,0 +1,281 @@
+import {
+  normalizeAuditEventItem
+} from "./chunk-LOKBGU6S.mjs";
+
+// src/types.ts
+var ArchivaError = class extends Error {
+  constructor(params) {
+    super(params.message);
+    this.statusCode = params.statusCode;
+    this.code = params.code;
+    this.retryAfterSeconds = params.retryAfterSeconds;
+    this.details = params.details;
+  }
+};
+
+// src/client.ts
+var DEFAULT_BASE_URL = "https://api.archiva.app";
+function buildHeaders(apiKey, overrides) {
+  const headers = new Headers(overrides);
+  headers.set("X-Project-Key", apiKey);
+  return headers;
+}
+async function parseError(response) {
+  const retryAfterHeader = response.headers.get("Retry-After");
+  const retryAfterSeconds = retryAfterHeader ? Number(retryAfterHeader) : void 0;
+  let payload = void 0;
+  try {
+    payload = await response.json();
+  } catch {
+    payload = void 0;
+  }
+  const errorMessage = typeof payload === "object" && payload !== null && "error" in payload ? String(payload.error) : response.statusText;
+  let code = "HTTP_ERROR";
+  if (response.status === 401) {
+    code = "UNAUTHORIZED";
+  } else if (response.status === 403) {
+    code = "FORBIDDEN";
+  } else if (response.status === 413) {
+    code = "PAYLOAD_TOO_LARGE";
+  } else if (response.status === 429) {
+    code = "RATE_LIMITED";
+  } else if (response.status === 409) {
+    code = "IDEMPOTENCY_CONFLICT";
+  }
+  throw new ArchivaError({
+    statusCode: response.status,
+    code,
+    message: errorMessage,
+    retryAfterSeconds,
+    details: payload
+  });
+}
+function createRequestId() {
+  if (typeof crypto !== "undefined" && crypto.randomUUID) {
+    return crypto.randomUUID();
+  }
+  return `${Date.now()}-${Math.random().toString(36).substring(2, 15)}`;
+}
+function createIdempotencyKey() {
+  if (typeof crypto !== "undefined" && crypto.randomUUID) {
+    return `idem_${crypto.randomUUID()}`;
+  }
+  return `idem_${Date.now()}-${Math.random().toString(36).substring(2, 15)}`;
+}
+async function loadEvents(apiKey, params, baseUrl = DEFAULT_BASE_URL) {
+  const url = new URL(`${baseUrl}/api/events`);
+  if (params.entityId) {
+    url.searchParams.set("entityId", params.entityId);
+  }
+  if (params.actorId) {
+    url.searchParams.set("actorId", params.actorId);
+  }
+  if (params.entityType) {
+    url.searchParams.set("entityType", params.entityType);
+  }
+  if (params.actorType) {
+    if (Array.isArray(params.actorType)) {
+      url.searchParams.set("actorType", params.actorType.join(","));
+    } else {
+      url.searchParams.set("actorType", params.actorType);
+    }
+  }
+  if (params.tenantId) {
+    url.searchParams.set("tenantId", params.tenantId);
+  }
+  if (params.actionKey) {
+    url.searchParams.set("actionKey", params.actionKey);
+  }
+  if (params.q) {
+    url.searchParams.set("q", params.q);
+  }
+  if (params.limit) {
+    url.searchParams.set("limit", String(params.limit));
+  }
+  if (params.cursor) {
+    url.searchParams.set("cursor", params.cursor);
+  }
+  const response = await fetch(url.toString(), {
+    headers: buildHeaders(apiKey)
+  });
+  if (!response.ok) {
+    await parseError(response);
+  }
+  const payload = await response.json();
+  if (!payload || typeof payload !== "object" || !Array.isArray(payload.items)) {
+    throw new ArchivaError({
+      statusCode: response.status,
+      code: "HTTP_ERROR",
+      message: "Invalid response format",
+      details: payload
+    });
+  }
+  const items = payload.items.map((item) => {
+    if (typeof item !== "object" || item === null) {
+      throw new ArchivaError({
+        statusCode: response.status,
+        code: "HTTP_ERROR",
+        message: "Invalid item format in response",
+        details: item
+      });
+    }
+    return normalizeAuditEventItem(item);
+  });
+  return {
+    items,
+    nextCursor: typeof payload.nextCursor === "string" ? payload.nextCursor : void 0
+  };
+}
+async function createEvent(apiKey, event, options, baseUrl = DEFAULT_BASE_URL) {
+  const idempotencyKey = options?.idempotencyKey ?? createIdempotencyKey();
+  const requestId = options?.requestId ?? createRequestId();
+  const headers = buildHeaders(apiKey, {
+    "Content-Type": "application/json",
+    "Idempotency-Key": idempotencyKey,
+    "X-Request-Id": requestId
+  });
+  const response = await fetch(`${baseUrl}/api/ingest/event`, {
+    method: "POST",
+    headers,
+    body: JSON.stringify(event)
+  });
+  if (!response.ok) {
+    await parseError(response);
+  }
+  const payload = await response.json();
+  if (!payload || typeof payload !== "object" || typeof payload.eventId !== "string") {
+    throw new ArchivaError({
+      statusCode: response.status,
+      code: "HTTP_ERROR",
+      message: "Invalid response format",
+      details: payload
+    });
+  }
+  return {
+    eventId: payload.eventId,
+    replayed: response.status === 200
+  };
+}
+async function createEvents(apiKey, events, options, baseUrl = DEFAULT_BASE_URL) {
+  const results = await Promise.all(
+    events.map(
+      (event, index) => createEvent(
+        apiKey,
+        event,
+        {
+          ...options,
+          idempotencyKey: options?.idempotencyKey ? `${options.idempotencyKey}_${index}` : void 0
+        },
+        baseUrl
+      )
+    )
+  );
+  return {
+    eventIds: results.map((r) => r.eventId)
+  };
+}
+
+// src/actions.ts
+var DEFAULT_BASE_URL2 = "https://api.archiva.app";
+function getApiKey(apiKey) {
+  const resolvedKey = apiKey || process.env.ARCHIVA_SECRET_KEY;
+  if (!resolvedKey) {
+    throw new Error("ARCHIVA_SECRET_KEY environment variable is required, or provide apiKey prop to ArchivaProvider");
+  }
+  return resolvedKey;
+}
+async function loadEvents2(params, apiKey) {
+  const resolvedApiKey = getApiKey(apiKey);
+  return loadEvents(resolvedApiKey, params, DEFAULT_BASE_URL2);
+}
+async function createEvent2(event, options, apiKey) {
+  const resolvedApiKey = getApiKey(apiKey);
+  return createEvent(resolvedApiKey, event, options, DEFAULT_BASE_URL2);
+}
+async function createEvents2(events, options, apiKey) {
+  const resolvedApiKey = getApiKey(apiKey);
+  return createEvents(resolvedApiKey, events, options, DEFAULT_BASE_URL2);
+}
+
+// src/server/frontendTokens.ts
+import "server-only";
+var DEFAULT_API_BASE_URL = "https://api.archiva.app";
+async function createFrontendTokenGET(projectId, apiBaseUrl = DEFAULT_API_BASE_URL) {
+  const secretKey = process.env.ARCHIVA_SECRET_KEY;
+  if (!secretKey || secretKey.trim().length === 0) {
+    const exists = process.env.ARCHIVA_SECRET_KEY !== void 0;
+    throw new Error(
+      `ARCHIVA_SECRET_KEY environment variable is ${exists ? "empty" : "not configured"}. Please set it in your .env.local file (or .env) with a valid value and restart your Next.js dev server. The variable must be in the project root directory and must not be empty.`
+    );
+  }
+  const keyPrefix = secretKey.substring(0, 10);
+  console.log("[Archiva] Using API key prefix:", keyPrefix + "...", "Length:", secretKey.length);
+  const url = new URL(`${apiBaseUrl}/api/v1/frontend-tokens`);
+  const response = await fetch(url.toString(), {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      "Authorization": `Bearer ${secretKey}`
+    },
+    body: JSON.stringify({
+      scopes: ["timeline:read"],
+      ...projectId && { projectId }
+    })
+  });
+  if (!response.ok) {
+    const error = await response.json().catch(() => ({ error: response.statusText }));
+    const errorMessage = error.error || `Failed to fetch frontend token: ${response.status}`;
+    if (errorMessage.includes("ARCHIVA_SECRET_KEY") || response.status === 401 || response.status === 403) {
+      throw new Error(
+        `Archiva API authentication failed. Check that your ARCHIVA_SECRET_KEY is valid and has the correct permissions. API error: ${errorMessage}`
+      );
+    }
+    throw new Error(errorMessage);
+  }
+  const data = await response.json();
+  if (!data.token || typeof data.expiresAt !== "number") {
+    throw new Error("Invalid token response format");
+  }
+  return {
+    token: data.token,
+    expiresAt: data.expiresAt
+  };
+}
+
+// src/server/handlers/createFrontendTokenRoute.ts
+import "server-only";
+import { NextResponse } from "next/server";
+var DEFAULT_API_BASE_URL2 = "https://api.archiva.app";
+function createFrontendTokenRoute(options) {
+  return async function GET2(request) {
+    try {
+      const searchParams = request.nextUrl.searchParams;
+      const projectId = searchParams.get("projectId") || void 0;
+      const apiBaseUrl = options?.apiBaseUrl || DEFAULT_API_BASE_URL2;
+      const tokenResponse = await createFrontendTokenGET(projectId, apiBaseUrl);
+      return NextResponse.json(tokenResponse);
+    } catch (error) {
+      console.error("Error fetching frontend token:", error);
+      const message = error instanceof Error ? error.message : "Internal server error";
+      const statusCode = message.includes("ARCHIVA_SECRET_KEY") ? 500 : 500;
+      return NextResponse.json(
+        { error: message },
+        { status: statusCode }
+      );
+    }
+  };
+}
+async function GET(request) {
+  const handler = createFrontendTokenRoute();
+  return handler(request);
+}
+
+export {
+  ArchivaError,
+  loadEvents2 as loadEvents,
+  createEvent2 as createEvent,
+  createEvents2 as createEvents,
+  createFrontendTokenGET,
+  createFrontendTokenRoute,
+  GET
+};

package/dist/chunk-LOKBGU6S.mjs

@@ -0,0 +1,88 @@
+// src/eventNormalizer.ts
+var coerceString = (value) => {
+  if (value === null || value === void 0) {
+    return void 0;
+  }
+  if (typeof value === "string") {
+    return value;
+  }
+  if (typeof value === "number" || typeof value === "boolean") {
+    return String(value);
+  }
+  return void 0;
+};
+var coerceNullableString = (value) => {
+  if (value === null || value === void 0) {
+    return null;
+  }
+  if (typeof value === "string") {
+    return value;
+  }
+  if (typeof value === "number" || typeof value === "boolean") {
+    return String(value);
+  }
+  return null;
+};
+var coerceActorType = (value) => {
+  if (typeof value !== "string") {
+    return void 0;
+  }
+  const normalized = value.toLowerCase();
+  if (normalized === "user" || normalized === "service" || normalized === "system") {
+    return normalized;
+  }
+  return void 0;
+};
+var getActorValue = (event, actorRecord, keys) => {
+  for (const key of keys) {
+    if (Object.prototype.hasOwnProperty.call(event, key)) {
+      return event[key];
+    }
+    if (actorRecord && Object.prototype.hasOwnProperty.call(actorRecord, key)) {
+      return actorRecord[key];
+    }
+  }
+  return void 0;
+};
+var normalizeAuditEventItem = (event) => {
+  const actorRecord = typeof event.actor === "object" && event.actor !== null ? event.actor : void 0;
+  const actorDisplayValue = getActorValue(event, actorRecord, [
+    "actorDisplay",
+    "actor_display",
+    "display",
+    "display_name",
+    "name"
+  ]);
+  const actorTypeValue = getActorValue(event, actorRecord, [
+    "actorType",
+    "actor_type",
+    "type"
+  ]);
+  const actorIdValue = getActorValue(event, actorRecord, [
+    "actorId",
+    "actor_id",
+    "id"
+  ]);
+  const actionKeyValue = coerceString(event.actionKey ?? event.action_key ?? event.action);
+  const actionDescriptionValue = coerceString(event.actionDescription ?? event.action_description);
+  const tenantIdValue = coerceString(event.tenantId ?? event.tenant_id);
+  return {
+    id: coerceString(event.id) ?? "",
+    receivedAt: coerceString(event.receivedAt ?? event.received_at) ?? "",
+    actionKey: actionKeyValue ?? "",
+    actionDescription: actionDescriptionValue ?? void 0,
+    tenantId: tenantIdValue ?? void 0,
+    // Legacy support: include action for backward compatibility
+    action: actionKeyValue ?? "",
+    entityType: coerceString(event.entityType ?? event.entity_type) ?? "",
+    entityId: coerceString(event.entityId ?? event.entity_id) ?? "",
+    actorId: coerceNullableString(actorIdValue),
+    actorType: coerceActorType(actorTypeValue),
+    actorDisplay: coerceString(actorDisplayValue) ?? "",
+    source: coerceNullableString(event.source)
+  };
+};
+
+export {
+  normalizeAuditEventItem
+};

package/dist/index-DfJ2Gf0Y.d.mts

@@ -0,0 +1,148 @@
+import { NextRequest, NextResponse } from 'next/server';
+
+type EventChange = {
+    op: "set" | "unset" | "add" | "remove" | "replace" | string;
+    path: string;
+    before?: unknown;
+    after?: unknown;
+};
+type CreateEventInput = {
+    actionKey?: string;
+    actionDescription?: string;
+    tenantId?: string;
+    action?: string;
+    entityType: string;
+    entityId: string;
+    actorType?: string;
+    actorId?: string;
+    actorDisplay?: string;
+    occurredAt?: string;
+    source?: string;
+    context?: Record<string, unknown>;
+    changes?: EventChange[];
+};
+type CreateEventOptions = {
+    idempotencyKey?: string;
+    requestId?: string;
+};
+type AuditEventListItem = {
+    id: string;
+    receivedAt: string;
+    actionKey: string;
+    actionDescription?: string;
+    tenantId?: string;
+    action?: string;
+    entityType: string;
+    entityId: string;
+    actorId: string | null;
+    actorType?: 'user' | 'service' | 'system';
+    actorDisplay: string;
+    source: string | null;
+};
+type PageResult<T> = {
+    items: T[];
+    nextCursor?: string;
+};
+type LoadEventsParams = {
+    entityId?: string;
+    actorId?: string;
+    entityType?: string;
+    actorType?: 'user' | 'service' | 'system' | ('user' | 'service' | 'system')[];
+    tenantId?: string;
+    actionKey?: string;
+    q?: string;
+    limit?: number;
+    cursor?: string;
+};
+declare class ArchivaError extends Error {
+    statusCode: number;
+    code: "UNAUTHORIZED" | "FORBIDDEN" | "PAYLOAD_TOO_LARGE" | "RATE_LIMITED" | "IDEMPOTENCY_CONFLICT" | "HTTP_ERROR";
+    retryAfterSeconds?: number;
+    details?: unknown;
+    constructor(params: {
+        statusCode: number;
+        code: "UNAUTHORIZED" | "FORBIDDEN" | "PAYLOAD_TOO_LARGE" | "RATE_LIMITED" | "IDEMPOTENCY_CONFLICT" | "HTTP_ERROR";
+        message: string;
+        retryAfterSeconds?: number;
+        details?: unknown;
+    });
+}
+
+/**
+ * Server action to load audit events
+ *
+ * @param params - Query parameters for filtering events
+ * @param apiKey - Optional API key (otherwise uses ARCHIVA_SECRET_KEY env var)
+ * @returns Paginated list of audit events
+ */
+declare function loadEvents(params: LoadEventsParams, apiKey?: string): Promise<PageResult<AuditEventListItem>>;
+/**
+ * Server action to create a single audit event
+ *
+ * @param event - Event data to create
+ * @param options - Optional idempotency and request ID options
+ * @param apiKey - Optional API key (otherwise uses ARCHIVA_SECRET_KEY env var)
+ * @returns Created event ID and replay status
+ */
+declare function createEvent(event: CreateEventInput, options?: CreateEventOptions, apiKey?: string): Promise<{
+    eventId: string;
+    replayed: boolean;
+}>;
+/**
+ * Server action to create multiple audit events (bulk)
+ *
+ * @param events - Array of events to create
+ * @param options - Optional idempotency and request ID options
+ * @param apiKey - Optional API key (otherwise uses ARCHIVA_SECRET_KEY env var)
+ * @returns Array of created event IDs
+ */
+declare function createEvents(events: CreateEventInput[], options?: CreateEventOptions, apiKey?: string): Promise<{
+    eventIds: string[];
+}>;
+
+interface FrontendTokenResponse {
+    token: string;
+    expiresAt: number;
+}
+/**
+ * Fetches a frontend token from the Archiva API
+ *
+ * @param projectId - Optional project ID for scoping
+ * @param apiBaseUrl - Archiva API base URL (defaults to https://api.archiva.app)
+ * @returns Frontend token response
+ */
+declare function createFrontendTokenGET(projectId?: string, apiBaseUrl?: string): Promise<FrontendTokenResponse>;
+
+/**
+ * Next.js route handler for GET /api/archiva/frontend-token
+ *
+ * This handler can be used in the host app's route file:
+ *
+ * ```ts
+ * // app/api/archiva/frontend-token/route.ts
+ * export { GET } from '@archiva/archiva-nextjs/server';
+ * ```
+ *
+ * Or with custom configuration:
+ *
+ * ```ts
+ * import { createFrontendTokenRoute } from '@archiva/archiva-nextjs/server';
+ *
+ * export const GET = createFrontendTokenRoute({
+ *   apiBaseUrl: process.env.ARCHIVA_API_URL,
+ * });
+ * ```
+ */
+declare function createFrontendTokenRoute(options?: {
+    apiBaseUrl?: string;
+}): (request: NextRequest) => Promise<NextResponse<FrontendTokenResponse> | NextResponse<{
+    error: string;
+}>>;
+/**
+ * Default GET handler (for direct export)
+ */
+declare function GET(request: NextRequest): Promise<NextResponse<FrontendTokenResponse> | NextResponse<{
+    error: string;
+}>>;
+
+export { ArchivaError as A, type CreateEventInput as C, type EventChange as E, type FrontendTokenResponse as F, GET as G, type LoadEventsParams as L, type PageResult as P, createEvents as a, createFrontendTokenGET as b, createEvent as c, createFrontendTokenRoute as d, type CreateEventOptions as e, type AuditEventListItem as f, loadEvents as l };

package/dist/index-DfJ2Gf0Y.d.ts

@@ -0,0 +1,148 @@
+import { NextRequest, NextResponse } from 'next/server';
+
+type EventChange = {
+    op: "set" | "unset" | "add" | "remove" | "replace" | string;
+    path: string;
+    before?: unknown;
+    after?: unknown;
+};
+type CreateEventInput = {
+    actionKey?: string;
+    actionDescription?: string;
+    tenantId?: string;
+    action?: string;
+    entityType: string;
+    entityId: string;
+    actorType?: string;
+    actorId?: string;
+    actorDisplay?: string;
+    occurredAt?: string;
+    source?: string;
+    context?: Record<string, unknown>;
+    changes?: EventChange[];
+};
+type CreateEventOptions = {
+    idempotencyKey?: string;
+    requestId?: string;
+};
+type AuditEventListItem = {
+    id: string;
+    receivedAt: string;
+    actionKey: string;
+    actionDescription?: string;
+    tenantId?: string;
+    action?: string;
+    entityType: string;
+    entityId: string;
+    actorId: string | null;
+    actorType?: 'user' | 'service' | 'system';
+    actorDisplay: string;
+    source: string | null;
+};
+type PageResult<T> = {
+    items: T[];
+    nextCursor?: string;
+};
+type LoadEventsParams = {
+    entityId?: string;
+    actorId?: string;
+    entityType?: string;
+    actorType?: 'user' | 'service' | 'system' | ('user' | 'service' | 'system')[];
+    tenantId?: string;
+    actionKey?: string;
+    q?: string;
+    limit?: number;
+    cursor?: string;
+};
+declare class ArchivaError extends Error {
+    statusCode: number;
+    code: "UNAUTHORIZED" | "FORBIDDEN" | "PAYLOAD_TOO_LARGE" | "RATE_LIMITED" | "IDEMPOTENCY_CONFLICT" | "HTTP_ERROR";
+    retryAfterSeconds?: number;
+    details?: unknown;
+    constructor(params: {
+        statusCode: number;
+        code: "UNAUTHORIZED" | "FORBIDDEN" | "PAYLOAD_TOO_LARGE" | "RATE_LIMITED" | "IDEMPOTENCY_CONFLICT" | "HTTP_ERROR";
+        message: string;
+        retryAfterSeconds?: number;
+        details?: unknown;
+    });
+}
+
+/**
+ * Server action to load audit events
+ *
+ * @param params - Query parameters for filtering events
+ * @param apiKey - Optional API key (otherwise uses ARCHIVA_SECRET_KEY env var)
+ * @returns Paginated list of audit events
+ */
+declare function loadEvents(params: LoadEventsParams, apiKey?: string): Promise<PageResult<AuditEventListItem>>;
+/**
+ * Server action to create a single audit event
+ *
+ * @param event - Event data to create
+ * @param options - Optional idempotency and request ID options
+ * @param apiKey - Optional API key (otherwise uses ARCHIVA_SECRET_KEY env var)
+ * @returns Created event ID and replay status
+ */
+declare function createEvent(event: CreateEventInput, options?: CreateEventOptions, apiKey?: string): Promise<{
+    eventId: string;
+    replayed: boolean;
+}>;
+/**
+ * Server action to create multiple audit events (bulk)
+ *
+ * @param events - Array of events to create
+ * @param options - Optional idempotency and request ID options
+ * @param apiKey - Optional API key (otherwise uses ARCHIVA_SECRET_KEY env var)
+ * @returns Array of created event IDs
+ */
+declare function createEvents(events: CreateEventInput[], options?: CreateEventOptions, apiKey?: string): Promise<{
+    eventIds: string[];
+}>;
+
+interface FrontendTokenResponse {
+    token: string;
+    expiresAt: number;
+}
+/**
+ * Fetches a frontend token from the Archiva API
+ *
+ * @param projectId - Optional project ID for scoping
+ * @param apiBaseUrl - Archiva API base URL (defaults to https://api.archiva.app)
+ * @returns Frontend token response
+ */
+declare function createFrontendTokenGET(projectId?: string, apiBaseUrl?: string): Promise<FrontendTokenResponse>;
+
+/**
+ * Next.js route handler for GET /api/archiva/frontend-token
+ *
+ * This handler can be used in the host app's route file:
+ *
+ * ```ts
+ * // app/api/archiva/frontend-token/route.ts
+ * export { GET } from '@archiva/archiva-nextjs/server';
+ * ```
+ *
+ * Or with custom configuration:
+ *
+ * ```ts
+ * import { createFrontendTokenRoute } from '@archiva/archiva-nextjs/server';
+ *
+ * export const GET = createFrontendTokenRoute({
+ *   apiBaseUrl: process.env.ARCHIVA_API_URL,
+ * });
+ * ```
+ */
+declare function createFrontendTokenRoute(options?: {
+    apiBaseUrl?: string;
+}): (request: NextRequest) => Promise<NextResponse<FrontendTokenResponse> | NextResponse<{
+    error: string;
+}>>;
+/**
+ * Default GET handler (for direct export)
+ */
+declare function GET(request: NextRequest): Promise<NextResponse<FrontendTokenResponse> | NextResponse<{
+    error: string;
+}>>;
+
+export { ArchivaError as A, type CreateEventInput as C, type EventChange as E, type FrontendTokenResponse as F, GET as G, type LoadEventsParams as L, type PageResult as P, createEvents as a, createFrontendTokenGET as b, createEvent as c, createFrontendTokenRoute as d, type CreateEventOptions as e, type AuditEventListItem as f, loadEvents as l };

package/dist/index.d.mts

@@ -1,5 +1,5 @@
 export { ArchivaProvider, ArchivaProviderProps } from './react/index.mjs';
-export { A as ArchivaError, f as AuditEventListItem, C as CreateEventInput, e as CreateEventOptions, E as EventChange, F as FrontendTokenResponse, G as GET, L as LoadEventsParams, P as PageResult, c as createEvent, a as createEvents, b as createFrontendTokenGET, d as createFrontendTokenRoute, l as loadEvents } from './index-Bk4DxULy.mjs';
+export { A as ArchivaError, f as AuditEventListItem, C as CreateEventInput, e as CreateEventOptions, E as EventChange, F as FrontendTokenResponse, G as GET, L as LoadEventsParams, P as PageResult, c as createEvent, a as createEvents, b as createFrontendTokenGET, d as createFrontendTokenRoute, l as loadEvents } from './index-DfJ2Gf0Y.mjs';
 import 'react/jsx-runtime';
 import 'react';
 import 'next/server';

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 export { ArchivaProvider, ArchivaProviderProps } from './react/index.js';
-export { A as ArchivaError, f as AuditEventListItem, C as CreateEventInput, e as CreateEventOptions, E as EventChange, F as FrontendTokenResponse, G as GET, L as LoadEventsParams, P as PageResult, c as createEvent, a as createEvents, b as createFrontendTokenGET, d as createFrontendTokenRoute, l as loadEvents } from './index-Bk4DxULy.js';
+export { A as ArchivaError, f as AuditEventListItem, C as CreateEventInput, e as CreateEventOptions, E as EventChange, F as FrontendTokenResponse, G as GET, L as LoadEventsParams, P as PageResult, c as createEvent, a as createEvents, b as createFrontendTokenGET, d as createFrontendTokenRoute, l as loadEvents } from './index-DfJ2Gf0Y.js';
 import 'react/jsx-runtime';
 import 'react';
 import 'next/server';