@mehdad67/apitogo 0.1.24

package/dist/declarations/lib/components/navigation/NavigationBadge.d.ts

@@ -0,0 +1,26 @@
+export declare const ColorMap: {
+    green: string;
+    blue: string;
+    yellow: string;
+    red: string;
+    purple: string;
+    indigo: string;
+    gray: string;
+    outline: string;
+};
+export declare const ColorMapInvert: {
+    green: string;
+    blue: string;
+    yellow: string;
+    red: string;
+    purple: string;
+    indigo: string;
+    gray: string;
+    outline: string;
+};
+export declare const NavigationBadge: ({ color, label, className, invert, }: {
+    color: keyof typeof ColorMap;
+    label: string;
+    className?: string;
+    invert?: boolean;
+}) => import("react/jsx-runtime").JSX.Element;

package/dist/declarations/lib/components/navigation/NavigationCategory.d.ts

@@ -0,0 +1,5 @@
+import type { NavigationCategory as NavigationCategoryType } from "../../../config/validators/NavigationSchema.js";
+export declare const NavigationCategory: import("react").MemoExoticComponent<({ category, onRequestClose, }: {
+    category: NavigationCategoryType;
+    onRequestClose?: () => void;
+}) => import("react/jsx-runtime").JSX.Element>;

package/dist/declarations/lib/components/navigation/NavigationFilterContext.d.ts

@@ -0,0 +1,8 @@
+import { type PropsWithChildren } from "react";
+type NavigationFilterContextType = {
+    query: string;
+    setQuery: (query: string) => void;
+};
+export declare const NavigationFilterProvider: ({ children }: PropsWithChildren) => import("react/jsx-runtime").JSX.Element;
+export declare const useNavigationFilter: () => NavigationFilterContextType;
+export {};

package/dist/declarations/lib/components/navigation/NavigationFilterInput.d.ts

@@ -0,0 +1,3 @@
+export declare const NavigationFilterInput: ({ placeholder, }: {
+    placeholder?: string;
+}) => import("react/jsx-runtime").JSX.Element;

package/dist/declarations/lib/components/navigation/NavigationItem.d.ts

@@ -0,0 +1,6 @@
+import type { NavigationItem as NavigationItemType } from "../../../config/validators/NavigationSchema.js";
+export declare const DATA_ANCHOR_ATTR = "data-anchor";
+export declare const NavigationItem: ({ item, onRequestClose, }: {
+    item: NavigationItemType;
+    onRequestClose?: () => void;
+}) => import("react/jsx-runtime").JSX.Element | null;

package/dist/declarations/lib/components/navigation/NavigationWrapper.d.ts

@@ -0,0 +1,7 @@
+import { type PropsWithChildren } from "react";
+export declare const NavigationWrapper: {
+    ({ children, className, }: PropsWithChildren<{
+        className?: string;
+    }>): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};

package/dist/declarations/lib/components/navigation/PoweredByZudoku.d.ts

@@ -0,0 +1,3 @@
+export declare const PoweredByZudoku: ({ className }: {
+    className?: string;
+}) => import("react/jsx-runtime").JSX.Element;

package/dist/declarations/lib/components/navigation/Toc.d.ts

@@ -0,0 +1,4 @@
+import type { TocEntry } from "../../../vite/mdx/rehype-extract-toc-with-jsx.js";
+export declare const Toc: ({ entries }: {
+    entries: TocEntry[];
+}) => import("react/jsx-runtime").JSX.Element;

package/dist/declarations/lib/components/navigation/ZuploLogo.d.ts

@@ -0,0 +1,3 @@
+import type * as React from "react";
+declare const ZuploLogo: (props: React.SVGProps<SVGSVGElement>) => import("react/jsx-runtime").JSX.Element;
+export default ZuploLogo;

package/dist/declarations/lib/components/navigation/utils.d.ts

@@ -0,0 +1,31 @@
+import type { NavigationCategory, NavigationItem } from "../../../config/validators/NavigationSchema.js";
+import type { UseAuthReturn } from "../../authentication/hook.js";
+import type { ZudokuContext } from "../../core/ZudokuContext.js";
+export type TraverseCallback<T> = (item: NavigationItem, parentCategories: NavigationItem[]) => T | void;
+export declare const traverseNavigation: <T>(navigation: NavigationItem[], callback: TraverseCallback<T>) => T | undefined;
+export declare const traverseNavigationItem: <T>(item: NavigationItem, callback: TraverseCallback<T>, parentCategories?: NavigationItem[]) => T | undefined;
+export declare const getItemPath: (item: NavigationItem) => string | undefined;
+export declare const getFirstMatchingPath: (item: NavigationItem) => string;
+export declare const useCurrentItem: () => import("../../../config/validators/NavigationSchema.js").NavigationDoc | undefined;
+export declare const useIsCategoryOpen: (category: NavigationCategory) => true | undefined;
+export declare const usePrevNext: () => {
+    prev?: {
+        label?: string;
+        id: string;
+    };
+    next?: {
+        label?: string;
+        id: string;
+    };
+};
+export declare const navigationListItem: (props?: ({
+    isActive?: boolean | null | undefined;
+    isMuted?: boolean | null | undefined;
+    isPending?: boolean | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+export declare const itemMatchesFilter: (item: NavigationItem, query: string) => boolean;
+export declare const shouldShowItem: ({ auth, context, filterQuery, }: {
+    auth: UseAuthReturn;
+    context: ZudokuContext;
+    filterQuery?: string;
+}) => (item: NavigationItem) => boolean;

package/dist/declarations/lib/core/RouteGuard.d.ts

@@ -0,0 +1,2 @@
+export declare const SEARCH_PROTECTED_SECTION = "protected";
+export declare const RouteGuard: () => import("react/jsx-runtime").JSX.Element | null;

package/dist/declarations/lib/core/ZudokuContext.d.ts

@@ -0,0 +1,124 @@
+import type { QueryClient } from "@tanstack/react-query";
+import type { ReactNode } from "react";
+import type { Location } from "react-router";
+import type { BundledTheme, HighlighterCore } from "shiki";
+import type { z } from "zod/mini";
+import type { HeaderNavigation } from "../../config/validators/HeaderNavigationSchema.js";
+import type { Navigation, ResolvedNavigationRule } from "../../config/validators/NavigationSchema.js";
+import type { CallbackContext, ProtectedRouteResult, ProtectedRoutesInput } from "../../config/validators/ProtectedRoutesSchema.js";
+import type { AiAssistantsConfig, FooterSchema } from "../../config/validators/ZudokuConfig.js";
+import type { AuthenticationPlugin } from "../authentication/authentication.js";
+import { type AuthState } from "../authentication/state.js";
+import type { SlotType } from "../components/context/SlotProvider.js";
+import type { MdxComponentsType } from "../util/MdxComponents.js";
+import { type ProfileNavigationItem, type ApitogoPlugin } from "./plugins.js";
+export interface ApitogoEvents {
+    location: (event: {
+        from?: Location;
+        to: Location;
+    }) => void;
+    auth: (auth: {
+        prev: AuthState;
+        next: AuthState;
+    }) => void;
+}
+export interface ApiIdentity {
+    authorizeRequest: (request: Request) => Promise<Request> | Request;
+    authorizationFields?: {
+        headers?: string[];
+        queryParams?: string[];
+    };
+    label: string;
+    id: string;
+}
+export type ApiKeyCache = "api-keys";
+type Metadata = Partial<{
+    title: string;
+    defaultTitle?: string;
+    description: string;
+    logo: string;
+    favicon: string;
+    generator: string;
+    applicationName: string;
+    referrer: string;
+    keywords: string[];
+    authors: string[];
+    creator: string;
+    publisher: string;
+}>;
+type Site = Partial<{
+    dir?: "ltr" | "rtl";
+    showPoweredBy?: boolean;
+    title?: string;
+    logo?: {
+        src: {
+            light: string;
+            dark: string;
+        };
+        width?: string | number;
+        alt?: string;
+        href?: string;
+        reloadDocument?: boolean;
+    };
+    banner?: {
+        message: ReactNode;
+        color?: "note" | "tip" | "info" | "caution" | "danger" | (string & {});
+        dismissible?: boolean;
+    };
+    footer?: z.infer<typeof FooterSchema>;
+}>;
+type HeaderConfig = {
+    navigation?: HeaderNavigation;
+    placements?: {
+        navigation?: "start" | "center" | "end";
+        search?: "start" | "center" | "end";
+        auth?: "start" | "center" | "end" | "navigation";
+    };
+};
+export type ZudokuContextOptions = {
+    basePath?: string;
+    canonicalUrlOrigin?: string;
+    metadata?: Metadata;
+    site?: Site;
+    header?: HeaderConfig;
+    aiAssistants?: AiAssistantsConfig;
+    authentication?: AuthenticationPlugin;
+    navigation?: Navigation;
+    navigationRules?: ResolvedNavigationRule[];
+    plugins?: ApitogoPlugin[];
+    slots?: Record<string, SlotType>;
+    UNSAFE_slotlets?: Record<string, SlotType>;
+    mdx?: {
+        components?: MdxComponentsType;
+    };
+    protectedRoutes?: ProtectedRoutesInput;
+    syntaxHighlighting?: {
+        highlighterPromise: Promise<HighlighterCore>;
+        themes?: {
+            light: BundledTheme;
+            dark: BundledTheme;
+        };
+    };
+};
+export declare const normalizeProtectedRoutes: (val: ProtectedRoutesInput) => Record<string, (c: CallbackContext) => ProtectedRouteResult> | undefined;
+export declare class ZudokuContext {
+    navigation: Navigation;
+    navigationRules: ResolvedNavigationRule[];
+    readonly authentication?: AuthenticationPlugin;
+    readonly getAuthState: () => AuthState;
+    readonly queryClient: QueryClient;
+    readonly options: ZudokuContextOptions;
+    readonly env: Record<string, string | undefined>;
+    readonly protectedRoutes: ReturnType<typeof normalizeProtectedRoutes>;
+    private readonly plugins;
+    private readonly emitter;
+    readonly initialize: Promise<void> | undefined;
+    constructor(options: ZudokuContextOptions, queryClient: QueryClient, env: Record<string, string | undefined>);
+    getApiIdentities: () => Promise<ApiIdentity[]>;
+    addEventListener<E extends keyof ApitogoEvents>(event: E, callback: ApitogoEvents[E]): import("nanoevents").Unsubscribe;
+    emitEvent: <E extends keyof ApitogoEvents>(event: E, ...data: Parameters<ApitogoEvents[E]>) => void;
+    getPluginNavigation: (path: string) => Promise<import("../../config/validators/NavigationSchema.js").NavigationItem[]>;
+    getProfileMenuItems: () => ProfileNavigationItem[];
+    signRequest: (request: Request) => Promise<Request>;
+}
+export {};

package/dist/declarations/lib/core/plugins.d.ts

@@ -0,0 +1,74 @@
+import type { LucideIcon } from "lucide-react";
+import type { HTMLAttributeAnchorTarget, ReactNode } from "react";
+import type { Location, RouteObject } from "react-router";
+import type { Navigation } from "../../config/validators/NavigationSchema.js";
+import type { ProtectedRoutesInput } from "../../config/validators/ProtectedRoutesSchema.js";
+import type { ZudokuConfig } from "../../config/validators/ZudokuConfig.js";
+import type { AuthenticationPlugin } from "../authentication/authentication.js";
+import type { MdxComponentsType } from "../util/MdxComponents.js";
+import type { ApiIdentity, ApitogoEvents, ZudokuContext } from "./ZudokuContext.js";
+export { runPluginTransformConfig } from "./transform-config.js";
+export type ApitogoPlugin = CommonPlugin | ProfileMenuPlugin | NavigationPlugin | ApiIdentityPlugin | SearchProviderPlugin | EventConsumerPlugin | AuthenticationPlugin | TransformConfigPlugin;
+export type { AuthenticationPlugin, RouteObject };
+export interface NavigationPlugin {
+    getRoutes: () => RouteObject[];
+    getNavigation?: (path: string, context: ZudokuContext) => Promise<Navigation>;
+    getProtectedRoutes?: () => ProtectedRoutesInput;
+}
+export declare const createApiIdentityPlugin: (plugin: ApiIdentityPlugin) => ApiIdentityPlugin;
+export declare const createProfileMenuPlugin: (plugin: ProfileMenuPlugin) => ProfileMenuPlugin;
+export interface ApiIdentityPlugin {
+    getIdentities: (context: ZudokuContext) => Promise<ApiIdentity[]>;
+}
+export interface SearchProviderPlugin {
+    renderSearch: (o: {
+        isOpen: boolean;
+        onClose: () => void;
+    }) => React.JSX.Element | null;
+}
+export interface ProfileMenuPlugin {
+    getProfileMenuItems: (context: ZudokuContext) => ProfileNavigationItem[];
+}
+export type ProfileNavigationItem = {
+    label: string;
+    path?: string;
+    target?: HTMLAttributeAnchorTarget;
+    weight?: number;
+    category?: "top" | "middle" | "bottom";
+    children?: ProfileNavigationItem[];
+    icon?: LucideIcon;
+};
+export interface ConfigHookContext {
+    mode: typeof process.env.ZUDOKU_ENV;
+    rootDir: string;
+    configPath: string;
+}
+export interface TransformConfigContext {
+    config: ZudokuConfig;
+    merge: <T extends Partial<ZudokuConfig>>(partial: T) => ZudokuConfig & T;
+}
+export interface TransformConfigPlugin {
+    transformConfig?: (context: TransformConfigContext) => ZudokuConfig | void | Promise<ZudokuConfig | void>;
+}
+export interface CommonPlugin {
+    initialize?: (context: ZudokuContext) => Promise<void | boolean> | void | boolean;
+    getHead?: (args: {
+        location: Location;
+    }) => ReactNode | undefined;
+    getMdxComponents?: () => MdxComponentsType;
+}
+export type EventConsumerPlugin<Event extends ApitogoEvents = ApitogoEvents> = {
+    events: {
+        [K in keyof Event]?: Event[K];
+    };
+};
+export declare const isEventConsumerPlugin: (obj: ApitogoPlugin) => obj is EventConsumerPlugin;
+export declare const isProfileMenuPlugin: (obj: ApitogoPlugin) => obj is ProfileMenuPlugin;
+export declare const isNavigationPlugin: (obj: ApitogoPlugin) => obj is NavigationPlugin;
+export declare const isAuthenticationPlugin: (obj: ApitogoPlugin) => obj is AuthenticationPlugin;
+export declare const isSearchPlugin: (obj: ApitogoPlugin) => obj is SearchProviderPlugin;
+export declare const needsInitialization: (obj: ApitogoPlugin) => obj is CommonPlugin;
+export declare const hasHead: (obj: ApitogoPlugin) => obj is CommonPlugin;
+export declare const isMdxProviderPlugin: (obj: ApitogoPlugin) => obj is CommonPlugin;
+export declare const isApiIdentityPlugin: (obj: ApitogoPlugin) => obj is ApiIdentityPlugin;
+export declare const isTransformConfigPlugin: (obj: ApitogoPlugin) => obj is TransformConfigPlugin;

package/dist/declarations/lib/core/react-query.d.ts

@@ -0,0 +1 @@
+export * from "@tanstack/react-query";

package/dist/declarations/lib/core/router.d.ts

@@ -0,0 +1 @@
+export * from "react-router";

package/dist/declarations/lib/core/transform-config.d.ts

@@ -0,0 +1,4 @@
+import type { ZudokuConfig } from "../../config/validators/ZudokuConfig.js";
+export declare const isPlainObject: (value: unknown) => value is Record<string, unknown>;
+export declare const mergeConfig: <T extends Record<string, unknown>, S extends Record<string, unknown>>(target: T, source: S) => T & S;
+export declare const runPluginTransformConfig: <T extends ZudokuConfig>(config: T) => Promise<T>;

package/dist/declarations/lib/demo/DemoAnnouncement.d.ts

@@ -0,0 +1,2 @@
+export declare const DemoAnnouncement: () => import("react/jsx-runtime").JSX.Element;
+export default DemoAnnouncement;

package/dist/declarations/lib/errors/ErrorAlert.d.ts

@@ -0,0 +1,3 @@
+export declare function ErrorAlert({ error }: {
+    error: unknown;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/declarations/lib/errors/ErrorMessage.d.ts

@@ -0,0 +1,3 @@
+export declare function ErrorMessage({ error }: {
+    error: unknown;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/declarations/lib/errors/RouterError.d.ts

@@ -0,0 +1,3 @@
+export declare function RouterError({ className }: {
+    className?: string;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/declarations/lib/errors/ServerError.d.ts

@@ -0,0 +1,3 @@
+export declare function ServerError({ error }: {
+    error: unknown;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/declarations/lib/errors/TopLevelError.d.ts

@@ -0,0 +1,2 @@
+import type { FallbackProps } from "react-error-boundary";
+export declare function TopLevelError({ error }: FallbackProps): import("react/jsx-runtime").JSX.Element;

package/dist/declarations/lib/hooks/index.d.ts

@@ -0,0 +1,8 @@
+export { useMDXComponents } from "@mdx-js/react";
+export { useTheme } from "next-themes";
+export { useAuth, useRefreshUserProfile, useVerifiedEmail, } from "../authentication/hook.js";
+export { CACHE_KEYS, useCache } from "../components/cache.js";
+export { useApitogo } from "../components/context/ZudokuContext.js";
+export { useZudoku } from "../components/context/ZudokuContext.js";
+export { useExposedProps } from "../util/useExposedProps.js";
+export { useEvent } from "./useEvent.js";

package/dist/declarations/lib/hooks/useEvent.d.ts

@@ -0,0 +1,5 @@
+import type { ApitogoEvents } from "../core/ZudokuContext.js";
+type EventParameters<Event extends keyof ApitogoEvents> = Parameters<ApitogoEvents[Event]>;
+export declare function useEvent<E extends keyof ApitogoEvents>(event: E): EventParameters<E>;
+export declare function useEvent<E extends keyof ApitogoEvents, R>(event: E, callback: (...args: EventParameters<E>) => R): R;
+export {};

package/dist/declarations/lib/hooks/useHighlighter.d.ts

@@ -0,0 +1,2 @@
+import type { HighlighterCore } from "shiki";
+export declare const useHighlighter: () => HighlighterCore;

package/dist/declarations/lib/hooks/useHotkey.d.ts

@@ -0,0 +1,4 @@
+export declare const useHotkey: (hotkey: string, callback: () => void) => {
+    trigger: () => void;
+    label: string[];
+};

package/dist/declarations/lib/icons.d.ts

@@ -0,0 +1,2 @@
+export * from "lucide-react";
+export * from "./MissingIcon.js";

package/dist/declarations/lib/navigation/applyRules.d.ts

@@ -0,0 +1,8 @@
+import type { NavigationItem, ResolvedNavigationRule } from "../../config/validators/NavigationSchema.js";
+export declare const SORTABLE_TYPES: readonly ["doc", "link", "category", "section"];
+export type SortableType = (typeof SORTABLE_TYPES)[number];
+export type ApplyRulesResult = {
+    result: NavigationItem[];
+    warnings: string[];
+};
+export declare const applyRules: (navigation: NavigationItem[], rules: ResolvedNavigationRule[], topNavLabel?: string) => ApplyRulesResult;

package/dist/declarations/lib/navigation/pathMatcher.d.ts

@@ -0,0 +1,11 @@
+import type { NavigationItem } from "../../config/validators/NavigationSchema.js";
+export type PathMatchResult = undefined | {
+    item: NavigationItem;
+    parentItems: NavigationItem[];
+    index: number;
+    isRoot?: false;
+} | {
+    parentItems: NavigationItem[];
+    isRoot: true;
+};
+export declare const findByPath: (navigation: NavigationItem[], pathString: string) => PathMatchResult;

package/dist/declarations/lib/oas/graphql/circular.d.ts

@@ -0,0 +1,3 @@
+import { GraphQLScalarType } from "graphql/index.js";
+export declare const handleCircularRefs: (obj: any, currentPath?: WeakSet<WeakKey>, refs?: WeakMap<WeakKey, any>, path?: string[], currentRefPaths?: Set<string>) => any;
+export declare const GraphQLJSONSchema: GraphQLScalarType<unknown, unknown>;

package/dist/declarations/lib/oas/graphql/constants.d.ts

@@ -0,0 +1,2 @@
+export declare const CIRCULAR_REF = "$[Circular Reference]";
+export declare const SCHEMA_REF_PREFIX = "$ref:";

package/dist/declarations/lib/oas/graphql/index.d.ts

@@ -0,0 +1,33 @@
+import { type YogaServerOptions } from "graphql-yoga";
+import { type CountableSlugify } from "../../util/slugify.js";
+import type { EncodingObject, ExampleObject, OpenAPIDocument, OperationObject, ParameterObject, PathsObject, SchemaObject, TagObject } from "../parser/index.js";
+export type { EncodingObject, ExampleObject, OpenAPIDocument, OperationObject, ParameterObject, PathsObject, SchemaObject, TagObject, };
+type OperationLike = {
+    summary?: string | null;
+    operationId?: string | null;
+    path: string;
+    method: string;
+};
+export declare const createOperationSlug: (slugify: CountableSlugify, operation: OperationLike) => string;
+export type SchemaImport = () => Promise<{
+    schema: OpenAPIDocument;
+}>;
+export type SchemaImports = Record<string, SchemaImport>;
+type Slugs = {
+    operations: Record<string, string>;
+    tags: Record<string, string>;
+};
+type GraphQLOperationObject = OperationObject & {
+    path: string;
+    method: string;
+    slug?: string;
+    parentTag?: string;
+};
+export declare const getAllTags: (schema: OpenAPIDocument) => Array<Omit<TagObject, "name"> & {
+    name?: string;
+    slug?: string;
+}>;
+export declare const getAllSlugs: (ops: GraphQLOperationObject[], schemaTags?: TagObject[]) => Slugs;
+export declare const getAllOperations: (paths?: PathsObject) => GraphQLOperationObject[];
+export declare const schema: import("graphql").GraphQLSchema;
+export declare const createGraphQLServer: (options?: Omit<YogaServerOptions<any, any>, "schema">) => import("graphql-yoga").YogaServerInstance<any, any>;

package/dist/declarations/lib/oas/parser/dereference/index.d.ts

@@ -0,0 +1,5 @@
+import type { JSONSchema4, JSONSchema6 } from "json-schema";
+export type JSONSchema = JSONSchema4 | JSONSchema6;
+type CustomResolver = (ref: string) => Promise<JSONSchema | undefined>;
+export declare const dereference: (schema: JSONSchema, resolvers?: CustomResolver[]) => Promise<JSONSchema>;
+export {};

package/dist/declarations/lib/oas/parser/dereference/resolveRef.d.ts

@@ -0,0 +1,2 @@
+import type { JSONSchema } from "./index.js";
+export declare const resolveLocalRef: (schema: JSONSchema, ref: string) => unknown;

package/dist/declarations/lib/oas/parser/index.d.ts

@@ -0,0 +1,25 @@
+import { OpenAPIV3, type OpenAPIV3_1 } from "openapi-types";
+interface WithRef {
+    __$ref?: string;
+}
+type DeepOmitReference<T> = T extends OpenAPIV3_1.ReferenceObject ? never : T extends object ? {
+    [K in keyof T]: DeepOmitReference<T[K]>;
+} & WithRef : T;
+export type OpenAPIDocument = DeepOmitReference<OpenAPIV3_1.Document>;
+export type ResponseObject = DeepOmitReference<OpenAPIV3_1.ResponseObject>;
+export type OperationObject = DeepOmitReference<OpenAPIV3_1.OperationObject>;
+export type PathsObject = DeepOmitReference<OpenAPIV3_1.PathsObject>;
+export type PathItemObject = DeepOmitReference<OpenAPIV3_1.PathItemObject>;
+export type ParameterObject = DeepOmitReference<OpenAPIV3_1.ParameterObject>;
+export type TagObject = DeepOmitReference<OpenAPIV3_1.TagObject>;
+export type ExampleObject = DeepOmitReference<OpenAPIV3_1.ExampleObject>;
+export type EncodingObject = DeepOmitReference<OpenAPIV3_1.EncodingObject>;
+export type SchemaObject = DeepOmitReference<OpenAPIV3_1.SchemaObject>;
+export type ArraySchemaObject = DeepOmitReference<OpenAPIV3_1.ArraySchemaObject>;
+export type ServerObject = DeepOmitReference<OpenAPIV3_1.ServerObject>;
+export type ContactObject = DeepOmitReference<OpenAPIV3_1.ContactObject>;
+export type LicenseObject = DeepOmitReference<OpenAPIV3_1.LicenseObject>;
+export type ExternalDocumentationObject = DeepOmitReference<OpenAPIV3_1.ExternalDocumentationObject>;
+export declare const HttpMethods: OpenAPIV3.HttpMethods[];
+export declare const validate: (schemaInput: unknown) => Promise<OpenAPIDocument>;
+export {};

package/dist/declarations/lib/oas/parser/upgrade/index.d.ts

@@ -0,0 +1,4 @@
+import { type RecordAny } from "../../../util/traverse.js";
+import type { OpenAPIDocument } from "../index.js";
+export declare const upgradeSchema: (schema: RecordAny) => OpenAPIDocument;
+export declare function isSchemaPath(path: string[]): boolean;

package/dist/declarations/lib/plugins/api-catalog/Catalog.d.ts

@@ -0,0 +1,4 @@
+import { type ApiCatalogPluginOptions } from "./index.js";
+export declare const Catalog: ({ items, filterCatalogItems, label, categoryLabel, }: Omit<ApiCatalogPluginOptions, "path"> & {
+    categoryLabel?: string;
+}) => import("react/jsx-runtime").JSX.Element;

package/dist/declarations/lib/plugins/api-catalog/index.d.ts

@@ -0,0 +1,31 @@
+import type { AuthState } from "../../authentication/state.js";
+import type { ApitogoPlugin } from "../../core/plugins.js";
+export declare const getKey: (category: string, tag: string) => string;
+export type ApiCatalogItem = {
+    path: string;
+    label: string;
+    description: string;
+    categories: CatalogCategory[];
+};
+export type CatalogCategory = {
+    label: string;
+    tags: string[];
+};
+export type ApiCatalogPluginOptions = {
+    path: string;
+    label: string;
+    categories?: CatalogCategory[];
+    items: ApiCatalogItem[];
+    filterCatalogItems?: FilterCatalogItemsFn;
+};
+export type CatalogContext = {
+    auth: AuthState;
+};
+export type FilterCatalogItemsFn = (items: ApiCatalogItem[], { auth }: CatalogContext) => ApiCatalogItem[];
+export declare const apiCatalogPlugin: ({ path, items, label, categories, filterCatalogItems, }: {
+    path: string;
+    label: string;
+    categories?: CatalogCategory[];
+    items: ApiCatalogItem[];
+    filterCatalogItems?: FilterCatalogItemsFn;
+}) => ApitogoPlugin;

package/dist/declarations/lib/plugins/api-keys/CreateApiKey.d.ts

@@ -0,0 +1,5 @@
+import type { ApiKeyService } from "./index.js";
+export declare const CreateApiKey: ({ service, onOpenChange, }: {
+    service: ApiKeyService;
+    onOpenChange: (open: boolean) => void;
+}) => import("react/jsx-runtime").JSX.Element | null;

package/dist/declarations/lib/plugins/api-keys/CreateApiKeyDialog.d.ts

@@ -0,0 +1,11 @@
+import type { ReactNode } from "react";
+import type { ApiKeyService } from "./index.js";
+interface CreateApiKeyDialogProps {
+    service: ApiKeyService;
+    isOpen: boolean;
+    onOpenChange: (open: boolean) => void;
+    trigger?: ReactNode;
+    buttonVariant?: "default" | "destructive" | "outline" | "secondary" | "ghost" | "link";
+}
+export declare const CreateApiKeyDialog: ({ service, isOpen, onOpenChange, trigger, buttonVariant, }: CreateApiKeyDialogProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/declarations/lib/plugins/api-keys/SettingsApiKeys.d.ts

@@ -0,0 +1,4 @@
+import type { ApiKeyService } from "./index.js";
+export declare const SettingsApiKeys: ({ service }: {
+    service: ApiKeyService;
+}) => import("react/jsx-runtime").JSX.Element;

package/dist/declarations/lib/plugins/api-keys/index.d.ts

@@ -0,0 +1,52 @@
+import type { ApiKeysOptions } from "../../../config/validators/ZudokuConfig.js";
+import type { UseAuthReturn } from "../../authentication/hook.js";
+import type { ApiIdentityPlugin, ProfileMenuPlugin, ApitogoPlugin } from "../../core/plugins.js";
+import type { ZudokuContext } from "../../core/ZudokuContext.js";
+export type ApiKeyService = {
+    getConsumers: (context: ZudokuContext) => Promise<ApiConsumer[]>;
+    rollKey?: (consumerId: string, context: ZudokuContext) => Promise<void>;
+    deleteKey?: (consumerId: string, keyId: string, context: ZudokuContext) => Promise<void>;
+    updateConsumer?: (consumer: {
+        id: string;
+        label?: string;
+    }, context: ZudokuContext) => Promise<void>;
+    getUsage?: (apiKeys: string[], context: ZudokuContext) => Promise<void>;
+    createKey?: ({ apiKey, context, auth, }: {
+        apiKey: {
+            description: string;
+            expiresOn?: string;
+        };
+        context: ZudokuContext;
+        auth: UseAuthReturn;
+    }) => Promise<void>;
+};
+export type ApiKeyPluginOptions = ApiKeyService | DefaultApiKeyServiceOptions;
+type DefaultApiKeyServiceOptions = {
+    deploymentName?: string;
+} & Partial<ApiKeyService>;
+export interface ApiKey {
+    id: string;
+    description?: string;
+    createdOn?: string;
+    updatedOn?: string;
+    expiresOn?: string;
+    key: string;
+}
+export interface ApiConsumer {
+    id: string;
+    label: string;
+    apiKeys: ApiKey[];
+    description?: string;
+    createdOn?: string;
+    updatedOn?: string;
+    expiresOn?: string;
+    key?: ApiKey;
+}
+export declare const createApiKeyService: <T extends ApiKeyService>(service: T) => T;
+type InternalApiKeyPluginOptions = {
+    deploymentName?: string;
+    isZuplo?: boolean;
+    path?: string;
+};
+export declare const apiKeyPlugin: ({ deploymentName, isZuplo, path, ...options }: Omit<ApiKeysOptions, "enabled"> & InternalApiKeyPluginOptions) => ApitogoPlugin & ApiIdentityPlugin & ProfileMenuPlugin;
+export {};

package/dist/declarations/lib/plugins/api-keys/settings/ApiKeyItem.d.ts

@@ -0,0 +1,12 @@
+import type { ZudokuContext } from "../../../core/ZudokuContext.js";
+import type { ApiConsumer } from "../index.js";
+declare const ApiKeyItem: ({ consumer, onUpdate, onRollKey, onDeleteKey, }: {
+    consumer: ApiConsumer;
+    onUpdate?: (data: {
+        label: string;
+        id: string;
+    }, context: ZudokuContext) => Promise<void>;
+    onRollKey?: (consumerId: string, context: ZudokuContext) => Promise<void>;
+    onDeleteKey?: (consumerId: string, keyId: string, context: ZudokuContext) => Promise<void>;
+}) => import("react/jsx-runtime").JSX.Element;
+export default ApiKeyItem;

package/dist/declarations/lib/plugins/api-keys/settings/ApiKeyList.d.ts

@@ -0,0 +1,4 @@
+import type { ApiKeyService } from "../index.js";
+export declare const ApiKeyList: ({ service }: {
+    service: ApiKeyService;
+}) => import("react/jsx-runtime").JSX.Element;