@mehdad67/apitogo 0.1.24

package/dist/declarations/lib/plugins/openapi/playground/ParamsGrid.d.ts

@@ -0,0 +1,17 @@
+declare const ParamsGrid: import("react").ForwardRefExoticComponent<Omit<import("react").ClassAttributes<HTMLDivElement> & import("react").HTMLAttributes<HTMLDivElement> & {
+    className?: import("clsx").ClassValue;
+    asChild?: boolean;
+}, "ref"> & import("react").RefAttributes<HTMLDivElement>>;
+export declare const ParamsGridItem: import("react").ForwardRefExoticComponent<Omit<import("react").ClassAttributes<HTMLDivElement> & import("react").HTMLAttributes<HTMLDivElement> & {
+    className?: import("clsx").ClassValue;
+    asChild?: boolean;
+}, "ref"> & import("react").RefAttributes<HTMLDivElement>>;
+export declare const ParamsGridInput: import("react").ForwardRefExoticComponent<Omit<import("react").InputHTMLAttributes<HTMLInputElement> & import("react").RefAttributes<HTMLInputElement> & {
+    className?: import("clsx").ClassValue;
+    asChild?: boolean;
+}, "ref"> & import("react").RefAttributes<HTMLInputElement>>;
+export declare const ParamsGridRemoveButton: ({ onClick, className, }: {
+    onClick: (e: React.MouseEvent<HTMLButtonElement>) => void;
+    className?: string;
+}) => import("react/jsx-runtime").JSX.Element;
+export default ParamsGrid;

package/dist/declarations/lib/plugins/openapi/playground/PathParams.d.ts

@@ -0,0 +1,6 @@
+import { type Control } from "react-hook-form";
+import type { PlaygroundForm } from "./Playground.js";
+export declare const PathParams: ({ control, url, }: {
+    control: Control<PlaygroundForm>;
+    url: string;
+}) => import("react/jsx-runtime").JSX.Element;

package/dist/declarations/lib/plugins/openapi/playground/Playground.d.ts

@@ -0,0 +1,89 @@
+import type { MediaTypeObject } from "../graphql/graphql.js";
+export declare const NO_IDENTITY = "__none";
+export type Header = {
+    name: string;
+    defaultValue?: string;
+    defaultActive?: boolean;
+    isRequired?: boolean;
+    enum?: string[];
+    type?: string;
+};
+export type QueryParam = {
+    name: string;
+    defaultValue?: string;
+    defaultActive?: boolean;
+    isRequired?: boolean;
+    enum?: string[];
+    type?: string;
+    style?: string;
+    explode?: boolean;
+    allowReserved?: boolean;
+};
+export type PathParam = {
+    name: string;
+    defaultValue?: string;
+    isRequired?: boolean;
+};
+export type PlaygroundForm = {
+    body: string;
+    bodyMode?: "text" | "file" | "multipart";
+    file?: File | null;
+    multipartFormFields: Array<{
+        name: string;
+        value: File | string;
+        active: boolean;
+    }>;
+    queryParams: Array<{
+        name: string;
+        value: string;
+        active: boolean;
+        enum?: string[];
+        type?: string;
+        style?: string;
+        explode?: boolean;
+        allowReserved?: boolean;
+    }>;
+    pathParams: Array<{
+        name: string;
+        value: string;
+    }>;
+    headers: Array<{
+        name: string;
+        value: string;
+        active: boolean;
+        enum?: string[];
+    }>;
+    identity?: string;
+};
+export type PlaygroundResult = {
+    status: number;
+    headers: Array<[string, string]>;
+    size: number;
+    body: string;
+    time: number;
+    isBinary?: boolean;
+    fileName?: string;
+    blob?: Blob;
+    request: {
+        method: string;
+        url: string;
+        headers: Array<[string, string]>;
+        body?: string;
+    };
+};
+export type PlaygroundContentProps = {
+    server?: string;
+    servers?: string[];
+    url: string;
+    method: string;
+    headers?: Header[];
+    queryParams?: QueryParam[];
+    pathParams?: PathParam[];
+    defaultBody?: string;
+    examples?: MediaTypeObject[];
+    requiresLogin?: boolean;
+    onLogin?: () => void;
+    onSignUp?: () => void;
+};
+export declare const Playground: ({ server, servers, url, method, headers, queryParams, pathParams, defaultBody, examples, requiresLogin, onLogin, onSignUp, }: PlaygroundContentProps) => import("react/jsx-runtime").JSX.Element;
+export default Playground;

package/dist/declarations/lib/plugins/openapi/playground/PlaygroundDialog.d.ts

@@ -0,0 +1,5 @@
+import { type PropsWithChildren } from "react";
+import { type PlaygroundContentProps } from "./Playground.js";
+export type PlaygroundDialogProps = PropsWithChildren<PlaygroundContentProps>;
+declare const PlaygroundDialog: (props: PlaygroundDialogProps) => import("react/jsx-runtime").JSX.Element;
+export { PlaygroundDialog };

package/dist/declarations/lib/plugins/openapi/playground/QueryParams.d.ts

@@ -0,0 +1,6 @@
+import { type Control } from "react-hook-form";
+import type { PlaygroundForm, QueryParam } from "./Playground.js";
+export declare const QueryParams: ({ control, schemaQueryParams, }: {
+    control: Control<PlaygroundForm>;
+    schemaQueryParams: QueryParam[];
+}) => import("react/jsx-runtime").JSX.Element;

package/dist/declarations/lib/plugins/openapi/playground/RequestLoginDialog.d.ts

@@ -0,0 +1,8 @@
+declare const RequestLoginDialog: ({ open, setOpen, onSignUp, onLogin, onSkip, }: {
+    open: boolean;
+    onSignUp?: () => void;
+    onLogin?: () => void;
+    setOpen: (open: boolean) => void;
+    onSkip?: (rememberSkip: boolean) => void;
+}) => import("react/jsx-runtime").JSX.Element;
+export default RequestLoginDialog;

package/dist/declarations/lib/plugins/openapi/playground/createUrl.d.ts

@@ -0,0 +1,2 @@
+import type { PlaygroundForm } from "./Playground.js";
+export declare const createUrl: (host: string, path: string, data: PlaygroundForm) => URL;

package/dist/declarations/lib/plugins/openapi/playground/fileUtils.d.ts

@@ -0,0 +1,3 @@
+export declare function isBinaryContentType(contentType: string): boolean;
+export declare function isAudioContentType(contentType: string): boolean;
+export declare const extractFileName: (headers: Array<[string, string]>, url: string) => string;

package/dist/declarations/lib/plugins/openapi/playground/rememberedIdentity.d.ts

@@ -0,0 +1,19 @@
+interface IdentityState {
+    rememberedIdentity: string | null;
+    setRememberedIdentity: (identity: string | null) => void;
+    getRememberedIdentity: (availableIdentities: string[]) => string | undefined;
+}
+export declare const useIdentityStore: import("zustand").UseBoundStore<Omit<import("zustand").StoreApi<IdentityState>, "setState" | "persist"> & {
+    setState(partial: IdentityState | Partial<IdentityState> | ((state: IdentityState) => IdentityState | Partial<IdentityState>), replace?: false | undefined): unknown;
+    setState(state: IdentityState | ((state: IdentityState) => IdentityState), replace: true): unknown;
+    persist: {
+        setOptions: (options: Partial<import("zustand/middleware").PersistOptions<IdentityState, unknown, unknown>>) => void;
+        clearStorage: () => void;
+        rehydrate: () => Promise<void> | void;
+        hasHydrated: () => boolean;
+        onHydrate: (fn: (state: IdentityState) => void) => () => void;
+        onFinishHydration: (fn: (state: IdentityState) => void) => () => void;
+        getOptions: () => Partial<import("zustand/middleware").PersistOptions<IdentityState, unknown, unknown>>;
+    };
+}>;
+export {};

package/dist/declarations/lib/plugins/openapi/playground/request-panel/MultipartField.d.ts

@@ -0,0 +1,8 @@
+import type { PlaygroundForm } from "../Playground.js";
+import type { useKeyValueFieldManager } from "./useKeyValueFieldManager.js";
+type MultipartFieldProps = {
+    index: number;
+    manager: ReturnType<typeof useKeyValueFieldManager<PlaygroundForm, "multipartFormFields">>;
+};
+export declare const MultipartField: ({ index, manager }: MultipartFieldProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/declarations/lib/plugins/openapi/playground/request-panel/UrlPath.d.ts

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

package/dist/declarations/lib/plugins/openapi/playground/request-panel/UrlQueryParams.d.ts

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

package/dist/declarations/lib/plugins/openapi/playground/request-panel/useKeyValueFieldManager.d.ts

@@ -0,0 +1,40 @@
+import { type ComponentPropsWithoutRef } from "react";
+import type { Control, FieldArrayPath, FieldArrayWithId, FieldValues, PathValue } from "react-hook-form";
+export type Value = string | number | readonly string[] | File | boolean | undefined;
+export type KeyValueField = {
+    name: string;
+    value: Value;
+    active: boolean;
+};
+export type KeyValueFieldManagerOptions<TFormData extends FieldValues, TName extends FieldArrayPath<TFormData>, T extends KeyValueField = PathValue<TFormData, TName>[number]> = {
+    control: Control<TFormData>;
+    name: TName;
+    defaultValue: T;
+    isEmpty?: (item: T) => boolean;
+    shouldSetActive?: (item: T) => boolean;
+};
+export type CheckboxProps = {
+    checked: boolean;
+    disabled?: boolean;
+    onCheckedChange: (checked: boolean) => void;
+};
+export type RemoveButtonProps = {
+    onClick: () => void;
+    disabled?: boolean;
+};
+type SetValueFn = (index: number, field: keyof KeyValueField, value: Value, options?: {
+    focus?: "next" | "previous";
+}) => void;
+type GetValueFn = (index: number, field: keyof KeyValueField) => Value;
+export type UseKeyValueFieldManagerReturn<TFormData extends FieldValues> = {
+    fields: FieldArrayWithId<TFormData>[];
+    getNameInputProps: GetInputPropsFn;
+    getValueInputProps: GetInputPropsFn;
+    getCheckboxProps: (index: number) => CheckboxProps;
+    getRemoveButtonProps: (index: number) => RemoveButtonProps;
+    setValue: SetValueFn;
+    getValue: GetValueFn;
+};
+type GetInputPropsFn = (index: number) => ComponentPropsWithoutRef<"input">;
+export declare const useKeyValueFieldManager: <TFormData extends FieldValues, TName extends FieldArrayPath<TFormData>, T extends KeyValueField = PathValue<TFormData, TName>[number]>(options: KeyValueFieldManagerOptions<TFormData, TName>) => UseKeyValueFieldManagerReturn<TFormData>;
+export {};

package/dist/declarations/lib/plugins/openapi/playground/result-panel/AudioPlayer.d.ts

@@ -0,0 +1,6 @@
+export declare const AudioPlayer: ({ blob, fileName, size, onDownload, }: {
+    blob: Blob;
+    fileName: string;
+    size: number;
+    onDownload: () => void;
+}) => import("react/jsx-runtime").JSX.Element;

package/dist/declarations/lib/plugins/openapi/playground/result-panel/ResponseStatusBar.d.ts

@@ -0,0 +1,8 @@
+export declare const ResponseStatusBar: ({ status, time, size, isFinished, progress, }: {
+    status?: number;
+    time?: number;
+    size?: number;
+    isFinished: boolean;
+    progress: number;
+}) => import("react/jsx-runtime").JSX.Element;
+export default ResponseStatusBar;

package/dist/declarations/lib/plugins/openapi/playground/result-panel/ResponseTab.d.ts

@@ -0,0 +1,14 @@
+export declare const ResponseTab: ({ body, headers, request, size, isBinary, fileName, blob, }: {
+    body?: string;
+    headers: Array<[string, string]>;
+    request: {
+        method: string;
+        url: string;
+        headers: Array<[string, string]>;
+        body?: string;
+    };
+    size: number;
+    isBinary?: boolean;
+    fileName?: string;
+    blob?: Blob;
+}) => import("react/jsx-runtime").JSX.Element;

package/dist/declarations/lib/plugins/openapi/playground/result-panel/ResultPanel.d.ts

@@ -0,0 +1,11 @@
+import type { UseMutationResult } from "@tanstack/react-query";
+import type { PlaygroundResult } from "../Playground.js";
+export declare const ResultPanel: ({ queryMutation, showLongRunningWarning, onCancel, tip, isFinished, progress, }: {
+    queryMutation: UseMutationResult<PlaygroundResult, Error, any>;
+    showLongRunningWarning?: boolean;
+    onCancel?: () => void;
+    isFinished: boolean;
+    progress: number;
+    tip?: React.ReactNode;
+}) => import("react/jsx-runtime").JSX.Element;
+export default ResultPanel;

package/dist/declarations/lib/plugins/openapi/playground/result-panel/convertToTypes.d.ts

@@ -0,0 +1,10 @@
+type JsonValue = string | number | boolean | null | JsonObject | JsonArray;
+type JsonObject = {
+    [key: string]: JsonValue;
+};
+type JsonArray = JsonValue[];
+export declare function generateInterface(obj: JsonObject, _indentation?: string): string;
+export declare function convertToTypes(json: JsonValue): {
+    lines: string[];
+};
+export {};

package/dist/declarations/lib/plugins/openapi/playground/serializeQueryParams.d.ts

@@ -0,0 +1,4 @@
+import type { PlaygroundForm } from "./Playground.js";
+export declare const parseArrayParamValue: (value: string) => string[];
+export declare const serializeQueryParam: (name: string, value: string, style?: string, explode?: boolean, allowReserved?: boolean, type?: string) => [string, string][];
+export declare const serializeQueryString: (params: PlaygroundForm["queryParams"]) => string;

package/dist/declarations/lib/plugins/openapi/playground/useRememberSkipLoginDialog.d.ts

@@ -0,0 +1,18 @@
+type RememberSkipLoginState = {
+    skipLogin: boolean;
+    setSkipLogin: (skipLogin: boolean) => void;
+};
+export declare const useRememberSkipLoginDialog: import("zustand").UseBoundStore<Omit<import("zustand").StoreApi<RememberSkipLoginState>, "setState" | "persist"> & {
+    setState(partial: RememberSkipLoginState | Partial<RememberSkipLoginState> | ((state: RememberSkipLoginState) => RememberSkipLoginState | Partial<RememberSkipLoginState>), replace?: false | undefined): unknown;
+    setState(state: RememberSkipLoginState | ((state: RememberSkipLoginState) => RememberSkipLoginState), replace: true): unknown;
+    persist: {
+        setOptions: (options: Partial<import("zustand/middleware").PersistOptions<RememberSkipLoginState, unknown, unknown>>) => void;
+        clearStorage: () => void;
+        rehydrate: () => Promise<void> | void;
+        hasHydrated: () => boolean;
+        onHydrate: (fn: (state: RememberSkipLoginState) => void) => () => void;
+        onFinishHydration: (fn: (state: RememberSkipLoginState) => void) => () => void;
+        getOptions: () => Partial<import("zustand/middleware").PersistOptions<RememberSkipLoginState, unknown, unknown>>;
+    };
+}>;
+export {};

package/dist/declarations/lib/plugins/openapi/processors/removeExtensions.d.ts

@@ -0,0 +1,8 @@
+import type { ProcessorArg } from "../../../../config/validators/BuildSchema.js";
+import type { OpenAPIDocument } from "../../../oas/parser/index.js";
+interface RemoveExtensionsOptions {
+    keys?: string[];
+    shouldRemove?: (key: string) => boolean;
+}
+export declare const removeExtensions: ({ keys, shouldRemove }?: RemoveExtensionsOptions) => ({ schema }: ProcessorArg) => OpenAPIDocument;
+export {};

package/dist/declarations/lib/plugins/openapi/processors/removeParameters.d.ts

@@ -0,0 +1,12 @@
+import type { ProcessorArg } from "../../../../config/validators/BuildSchema.js";
+import type { OpenAPIDocument } from "../../../oas/parser/index.js";
+import { type RecordAny } from "./traverse.js";
+interface RemoveParametersOptions {
+    names?: string[];
+    in?: string[];
+    shouldRemove?: ({ parameter }: {
+        parameter: RecordAny;
+    }) => boolean;
+}
+export declare const removeParameters: ({ names, in: locations, shouldRemove }?: RemoveParametersOptions) => ({ schema }: ProcessorArg) => OpenAPIDocument;
+export {};

package/dist/declarations/lib/plugins/openapi/processors/removePaths.d.ts

@@ -0,0 +1,13 @@
+import type { ProcessorArg } from "../../../../config/validators/BuildSchema.js";
+import type { OpenAPIDocument } from "../../../oas/parser/index.js";
+import { type RecordAny } from "./traverse.js";
+interface RemovePathsOptions {
+    paths?: Record<string, true | string[]>;
+    shouldRemove?: (options: {
+        path: string;
+        method: true | string;
+        operation: RecordAny;
+    }) => boolean;
+}
+export declare const removePaths: ({ paths, shouldRemove }: RemovePathsOptions) => ({ schema }: ProcessorArg) => OpenAPIDocument;
+export {};

package/dist/declarations/lib/plugins/openapi/processors/traverse.d.ts

@@ -0,0 +1 @@
+export { type RecordAny, traverse } from "../../../util/traverse.js";

package/dist/declarations/lib/plugins/openapi/schema/SchemaExampleAndDefault.d.ts

@@ -0,0 +1,4 @@
+import type { SchemaObject } from "../../../oas/parser/index.js";
+export declare const SchemaExampleAndDefault: ({ schema, }: {
+    schema: SchemaObject;
+}) => import("react/jsx-runtime").JSX.Element | null;

package/dist/declarations/lib/plugins/openapi/schema/SchemaPropertyItem.d.ts

@@ -0,0 +1,8 @@
+import type { SchemaObject } from "../../../oas/parser/index.js";
+export declare const SchemaPropertyItem: ({ name, schema, group, defaultOpen, showCollapseButton, }: {
+    name: string;
+    schema: SchemaObject;
+    group: "required" | "optional" | "deprecated";
+    defaultOpen?: boolean;
+    showCollapseButton?: boolean;
+}) => import("react/jsx-runtime").JSX.Element;

package/dist/declarations/lib/plugins/openapi/schema/SchemaView.d.ts

@@ -0,0 +1,7 @@
+import type { SchemaObject } from "../../../oas/parser/index.js";
+export declare const SchemaView: ({ schema, defaultOpen, cardHeader, embedded, }: {
+    schema?: SchemaObject | null;
+    defaultOpen?: boolean;
+    cardHeader?: React.ReactNode;
+    embedded?: boolean;
+}) => import("react/jsx-runtime").JSX.Element | undefined;

package/dist/declarations/lib/plugins/openapi/schema/UnionView.d.ts

@@ -0,0 +1,5 @@
+import type { SchemaObject } from "../../../oas/parser/index.js";
+export declare const UnionView: ({ schema, cardHeader, }: {
+    schema: SchemaObject;
+    cardHeader?: React.ReactNode;
+}) => import("react/jsx-runtime").JSX.Element | null;

package/dist/declarations/lib/plugins/openapi/schema/union-helpers.d.ts

@@ -0,0 +1,28 @@
+import type { SchemaObject } from "../../../oas/parser/index.js";
+export type FieldSignature = {
+    type?: SchemaObject["type"];
+    const?: unknown;
+    enum?: unknown[];
+    format?: string;
+    pattern?: string;
+    minimum?: number;
+    maximum?: number;
+    exclusiveMinimum?: boolean | number;
+    exclusiveMaximum?: boolean | number;
+    minLength?: number;
+    maxLength?: number;
+    minItems?: number;
+    maxItems?: number;
+    itemsType?: string | string[];
+    additionalProps?: "true" | "false" | "schema";
+};
+export type FieldDoc = {
+    name: string;
+    humanType: string;
+    description?: string;
+    requiredInAll: boolean;
+};
+export declare const unionVariants: (schema: SchemaObject) => SchemaObject[];
+export declare const decideExclusivity: (schema: SchemaObject) => "exactly-one" | "at-least-one";
+export declare const labelForVariant: (index: number, variant: SchemaObject) => string;
+export declare const quickGuards: (variant: SchemaObject, root?: SchemaObject) => string[];

package/dist/declarations/lib/plugins/openapi/schema/utils.d.ts

@@ -0,0 +1,9 @@
+import type { ArraySchemaObject, SchemaObject } from "../../../oas/parser/index.js";
+export declare const isBasicType: (type: unknown) => type is "string" | "number" | "boolean" | "integer" | "null";
+export declare const isArrayType: (value: SchemaObject) => value is ArraySchemaObject;
+export declare const isComplexType: (value?: SchemaObject) => boolean | undefined;
+export declare const isCircularRef: (schema: unknown) => schema is string;
+export declare const isArrayCircularRef: (schema: SchemaObject) => schema is SchemaObject & {
+    items: SchemaObject;
+};
+export declare const extractCircularRefInfo: (ref?: string | SchemaObject) => string | undefined;

package/dist/declarations/lib/plugins/openapi/state.d.ts

@@ -0,0 +1,24 @@
+interface SelectedServerState {
+    selectedServer?: string;
+    setSelectedServer: (newServer: string) => void;
+}
+export declare const useSelectedServerStore: import("zustand").UseBoundStore<Omit<import("zustand").StoreApi<SelectedServerState>, "setState" | "persist"> & {
+    setState(partial: SelectedServerState | Partial<SelectedServerState> | ((state: SelectedServerState) => SelectedServerState | Partial<SelectedServerState>), replace?: false | undefined): unknown;
+    setState(state: SelectedServerState | ((state: SelectedServerState) => SelectedServerState), replace: true): unknown;
+    persist: {
+        setOptions: (options: Partial<import("zustand/middleware").PersistOptions<SelectedServerState, SelectedServerState, unknown>>) => void;
+        clearStorage: () => void;
+        rehydrate: () => Promise<void> | void;
+        hasHydrated: () => boolean;
+        onHydrate: (fn: (state: SelectedServerState) => void) => () => void;
+        onFinishHydration: (fn: (state: SelectedServerState) => void) => () => void;
+        getOptions: () => Partial<import("zustand/middleware").PersistOptions<SelectedServerState, SelectedServerState, unknown>>;
+    };
+}>;
+export declare const useSelectedServer: (servers: Array<{
+    url: string;
+}>) => {
+    selectedServer: string;
+    setSelectedServer: (newServer: string) => void;
+};
+export {};

package/dist/declarations/lib/plugins/openapi/util/buildTagCategories.d.ts

@@ -0,0 +1,12 @@
+import type { NavigationItem } from "../../../../config/validators/NavigationSchema.js";
+type TagGroup = {
+    name: string;
+    tags: string[];
+};
+type BuildTagCategoriesOptions = {
+    tagCategories: Map<string, NavigationItem>;
+    tagGroups: TagGroup[];
+    expandAllTags?: boolean;
+};
+export declare const buildTagCategories: ({ tagCategories, tagGroups, expandAllTags, }: BuildTagCategoriesOptions) => NavigationItem[];
+export {};

package/dist/declarations/lib/plugins/openapi/util/createHttpSnippet.d.ts

@@ -0,0 +1,11 @@
+import { HTTPSnippet } from "@zudoku/httpsnippet";
+import type { OperationsFragmentFragment } from "../graphql/graphql.js";
+export declare const createHttpSnippet: ({ operation, selectedServer, exampleBody, }: {
+    operation: OperationsFragmentFragment;
+    selectedServer: string;
+    exampleBody: {
+        mimeType: string;
+        text?: string;
+    };
+}) => HTTPSnippet;
+export declare const getConverted: (snippet: HTTPSnippet, option: string) => any;

package/dist/declarations/lib/plugins/openapi/util/createNavigationCategory.d.ts

@@ -0,0 +1,9 @@
+import type { NavigationItem } from "../../../../config/validators/NavigationSchema.js";
+import type { OperationResult } from "../index.js";
+export declare const createNavigationCategory: ({ label, path, operations, collapsible, collapsed, }: {
+    label: string;
+    path: string;
+    operations: OperationResult[];
+    collapsible?: boolean;
+    collapsed?: boolean;
+}) => NavigationItem;

package/dist/declarations/lib/plugins/openapi/util/generateSchemaExample.d.ts

@@ -0,0 +1,2 @@
+import type { SchemaObject } from "../../../oas/graphql/index.js";
+export declare const generateSchemaExample: (schema?: SchemaObject, name?: string) => any;

package/dist/declarations/lib/plugins/openapi/util/getRoutes.d.ts

@@ -0,0 +1,18 @@
+import { type RouteObject } from "react-router";
+import type { GraphQLClient } from "../client/GraphQLClient.js";
+import { type OpenApiPluginOptions } from "../index.js";
+import type { OasPluginConfig, VersionEntry } from "../interfaces.js";
+export declare const getVersionMetadata: (config: OasPluginConfig) => {
+    versions: string[];
+    versionMap: Record<string, {
+        label: string;
+        downloadUrl?: string;
+        tagPages?: string[];
+    }>;
+};
+export declare const buildVersionSwitchUrl: (target: VersionEntry, currentTag: string | undefined) => string;
+export declare const getRoutes: ({ basePath, config, client, }: {
+    client: GraphQLClient;
+    config: OpenApiPluginOptions;
+    basePath: string;
+}) => RouteObject[];

package/dist/declarations/lib/plugins/openapi/util/methodColorMap.d.ts

@@ -0,0 +1,2 @@
+import type { ColorMap } from "../../../components/navigation/NavigationBadge.js";
+export declare const MethodColorMap: Record<string, keyof typeof ColorMap>;

package/dist/declarations/lib/plugins/openapi/util/methodToColor.d.ts

@@ -0,0 +1,20 @@
+export declare const TextColorMap: {
+    green: string;
+    blue: string;
+    yellow: string;
+    red: string;
+    purple: string;
+    indigo: string;
+    gray: string;
+};
+export declare const methodToColor: {
+    get: string;
+    post: string;
+    put: string;
+    delete: string;
+    patch: string;
+    options: string;
+    head: string;
+    trace: string;
+};
+export declare const methodForColor: (method: string) => string;

package/dist/declarations/lib/plugins/openapi/util/sanitizeMarkdownForMetatag.d.ts

@@ -0,0 +1 @@
+export declare function sanitizeMarkdownForMetatag(description: string, maxLength?: number): string;

package/dist/declarations/lib/plugins/openapi/util/useWarmupSchema.d.ts

@@ -0,0 +1 @@
+export declare const useWarmupSchema: () => void;

package/dist/declarations/lib/plugins/search-inkeep/index.d.ts

@@ -0,0 +1,8 @@
+import type { InkeepBaseSettings, InkeepJS } from "@inkeep/cxkit-types";
+import type { ApitogoPlugin } from "../../core/plugins.js";
+declare global {
+    interface Window {
+        Inkeep: InkeepJS | undefined;
+    }
+}
+export declare const inkeepSearchPlugin: (settings: InkeepBaseSettings) => ApitogoPlugin;

package/dist/declarations/lib/plugins/search-inkeep/inkeep.d.ts

@@ -0,0 +1,6 @@
+import type { InkeepAIChatSettings, InkeepBaseSettings, InkeepModalSettings, InkeepSearchSettings } from "@inkeep/cxkit-types";
+declare const baseSettings: InkeepBaseSettings;
+declare const modalSettings: InkeepModalSettings;
+declare const searchSettings: InkeepSearchSettings;
+declare const aiChatSettings: InkeepAIChatSettings;
+export { aiChatSettings, baseSettings, modalSettings, searchSettings };

package/dist/declarations/lib/plugins/search-pagefind/IndexingDialog.d.ts

@@ -0,0 +1,3 @@
+import { type PropsWithChildren } from "react";
+declare const IndexingDialog: ({ children }: PropsWithChildren) => import("react/jsx-runtime").JSX.Element;
+export default IndexingDialog;

package/dist/declarations/lib/plugins/search-pagefind/PagefindSearch.d.ts

@@ -0,0 +1,6 @@
+import type { PagefindOptions } from "./index.js";
+export declare const PagefindSearch: ({ isOpen, onClose, options, }: {
+    isOpen: boolean;
+    onClose: () => void;
+    options: PagefindOptions;
+}) => import("react/jsx-runtime").JSX.Element;

package/dist/declarations/lib/plugins/search-pagefind/ResultList.d.ts

@@ -0,0 +1,8 @@
+import type { PagefindSearchFragment } from "./types.js";
+export declare const ResultList: ({ basePath, searchResults, searchTerm, onClose, maxSubResults, }: {
+    basePath?: string;
+    searchResults: PagefindSearchFragment[];
+    searchTerm: string;
+    onClose: () => void;
+    maxSubResults?: number;
+}) => import("react/jsx-runtime").JSX.Element;

package/dist/declarations/lib/plugins/search-pagefind/get-results.d.ts

@@ -0,0 +1,10 @@
+import type { AuthState } from "../../authentication/state.js";
+import type { ZudokuContext } from "../../core/ZudokuContext.js";
+import type { PagefindOptions } from "./index.js";
+import type { PagefindSearchFragment, PagefindSearchResults } from "./types.js";
+export declare const getResults: ({ search, options, auth, context, }: {
+    search: PagefindSearchResults;
+    options: PagefindOptions;
+    auth: AuthState;
+    context: ZudokuContext;
+}) => Promise<PagefindSearchFragment[]>;

package/dist/declarations/lib/plugins/search-pagefind/index.d.ts

@@ -0,0 +1,6 @@
+import type { ZudokuConfig } from "../../../config/validators/ZudokuConfig.js";
+import type { ApitogoPlugin } from "../../core/plugins.js";
+export type PagefindOptions = Extract<ZudokuConfig["search"], {
+    type: "pagefind";
+}>;
+export declare const pagefindSearchPlugin: (options: PagefindOptions) => ApitogoPlugin;