@mehdad67/apitogo 0.1.24

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

@@ -0,0 +1,528 @@
+import type { DocumentTypeDecoration } from "@graphql-typed-document-node/core";
+export type Maybe<T> = T | null;
+export type InputMaybe<T> = T | null | undefined;
+export type Exact<T extends {
+    [key: string]: unknown;
+}> = {
+    [K in keyof T]: T[K];
+};
+export type MakeOptional<T, K extends keyof T> = Omit<T, K> & {
+    [SubKey in K]?: Maybe<T[SubKey]>;
+};
+export type MakeMaybe<T, K extends keyof T> = Omit<T, K> & {
+    [SubKey in K]: Maybe<T[SubKey]>;
+};
+export type MakeEmpty<T extends {
+    [key: string]: unknown;
+}, K extends keyof T> = {
+    [_ in K]?: never;
+};
+export type Incremental<T> = T | {
+    [P in keyof T]?: P extends " $fragmentName" | "__typename" ? T[P] : never;
+};
+export type Scalars = {
+    ID: {
+        input: string;
+        output: string;
+    };
+    String: {
+        input: string;
+        output: string;
+    };
+    Boolean: {
+        input: boolean;
+        output: boolean;
+    };
+    Int: {
+        input: number;
+        output: number;
+    };
+    Float: {
+        input: number;
+        output: number;
+    };
+    JSON: {
+        input: any;
+        output: any;
+    };
+    JSONObject: {
+        input: any;
+        output: any;
+    };
+    JSONSchema: {
+        input: any;
+        output: any;
+    };
+};
+export type Components = {
+    __typename?: "Components";
+    schemas?: Maybe<Array<SchemaItem>>;
+};
+export type EncodingItem = {
+    __typename?: "EncodingItem";
+    allowReserved?: Maybe<Scalars["Boolean"]["output"]>;
+    contentType?: Maybe<Scalars["String"]["output"]>;
+    explode?: Maybe<Scalars["Boolean"]["output"]>;
+    headers?: Maybe<Scalars["JSONObject"]["output"]>;
+    name: Scalars["String"]["output"];
+    style?: Maybe<Scalars["String"]["output"]>;
+};
+export type ExampleItem = {
+    __typename?: "ExampleItem";
+    description?: Maybe<Scalars["String"]["output"]>;
+    externalValue?: Maybe<Scalars["String"]["output"]>;
+    name: Scalars["String"]["output"];
+    summary?: Maybe<Scalars["String"]["output"]>;
+    value?: Maybe<Scalars["JSON"]["output"]>;
+};
+export type MediaTypeObject = {
+    __typename?: "MediaTypeObject";
+    encoding?: Maybe<Array<EncodingItem>>;
+    examples?: Maybe<Array<ExampleItem>>;
+    mediaType: Scalars["String"]["output"];
+    schema?: Maybe<Scalars["JSONSchema"]["output"]>;
+};
+export type OperationItem = {
+    __typename?: "OperationItem";
+    contentTypes: Array<Scalars["String"]["output"]>;
+    deprecated?: Maybe<Scalars["Boolean"]["output"]>;
+    description?: Maybe<Scalars["String"]["output"]>;
+    extensions?: Maybe<Scalars["JSONObject"]["output"]>;
+    method: Scalars["String"]["output"];
+    operationId?: Maybe<Scalars["String"]["output"]>;
+    parameters?: Maybe<Array<ParameterItem>>;
+    path: Scalars["String"]["output"];
+    requestBody?: Maybe<RequestBodyObject>;
+    responses: Array<ResponseItem>;
+    servers: Array<Server>;
+    slug: Scalars["String"]["output"];
+    summary?: Maybe<Scalars["String"]["output"]>;
+    tags?: Maybe<Array<TagItem>>;
+};
+export type ParameterIn = "cookie" | "header" | "path" | "query";
+export type ParameterItem = {
+    __typename?: "ParameterItem";
+    allowEmptyValue?: Maybe<Scalars["Boolean"]["output"]>;
+    allowReserved?: Maybe<Scalars["Boolean"]["output"]>;
+    deprecated?: Maybe<Scalars["Boolean"]["output"]>;
+    description?: Maybe<Scalars["String"]["output"]>;
+    examples?: Maybe<Array<ExampleItem>>;
+    explode?: Maybe<Scalars["Boolean"]["output"]>;
+    extensions?: Maybe<Scalars["JSONObject"]["output"]>;
+    in: ParameterIn;
+    name: Scalars["String"]["output"];
+    required?: Maybe<Scalars["Boolean"]["output"]>;
+    schema?: Maybe<Scalars["JSONSchema"]["output"]>;
+    style?: Maybe<Scalars["String"]["output"]>;
+};
+export type PathItem = {
+    __typename?: "PathItem";
+    methods: Array<Scalars["String"]["output"]>;
+    path: Scalars["String"]["output"];
+};
+export type Query = {
+    __typename?: "Query";
+    schema: Schema;
+};
+export type QuerySchemaArgs = {
+    input: Scalars["JSON"]["input"];
+    type: SchemaType;
+};
+export type RequestBodyObject = {
+    __typename?: "RequestBodyObject";
+    content?: Maybe<Array<MediaTypeObject>>;
+    description?: Maybe<Scalars["String"]["output"]>;
+    required?: Maybe<Scalars["Boolean"]["output"]>;
+};
+export type ResponseItem = {
+    __typename?: "ResponseItem";
+    content?: Maybe<Array<MediaTypeObject>>;
+    description?: Maybe<Scalars["String"]["output"]>;
+    extensions?: Maybe<Scalars["JSONObject"]["output"]>;
+    headers?: Maybe<Scalars["JSON"]["output"]>;
+    links?: Maybe<Scalars["JSON"]["output"]>;
+    statusCode: Scalars["String"]["output"];
+};
+export type Schema = {
+    __typename?: "Schema";
+    components?: Maybe<Components>;
+    contact?: Maybe<SchemaContact>;
+    description?: Maybe<Scalars["String"]["output"]>;
+    extensions?: Maybe<Scalars["JSONObject"]["output"]>;
+    externalDocs?: Maybe<SchemaExternalDocs>;
+    license?: Maybe<SchemaLicense>;
+    openapi: Scalars["String"]["output"];
+    operations: Array<OperationItem>;
+    paths: Array<PathItem>;
+    servers: Array<Server>;
+    summary?: Maybe<Scalars["String"]["output"]>;
+    tag?: Maybe<SchemaTag>;
+    tags: Array<SchemaTag>;
+    termsOfService?: Maybe<Scalars["String"]["output"]>;
+    title: Scalars["String"]["output"];
+    url?: Maybe<Scalars["String"]["output"]>;
+    version: Scalars["String"]["output"];
+    webhooks: Array<WebhookItem>;
+};
+export type SchemaOperationsArgs = {
+    method?: InputMaybe<Scalars["String"]["input"]>;
+    operationId?: InputMaybe<Scalars["String"]["input"]>;
+    path?: InputMaybe<Scalars["String"]["input"]>;
+    tag?: InputMaybe<Scalars["String"]["input"]>;
+    untagged?: InputMaybe<Scalars["Boolean"]["input"]>;
+};
+export type SchemaTagArgs = {
+    name?: InputMaybe<Scalars["String"]["input"]>;
+    slug?: InputMaybe<Scalars["String"]["input"]>;
+    untagged?: InputMaybe<Scalars["Boolean"]["input"]>;
+};
+export type SchemaContact = {
+    __typename?: "SchemaContact";
+    email?: Maybe<Scalars["String"]["output"]>;
+    name?: Maybe<Scalars["String"]["output"]>;
+    url?: Maybe<Scalars["String"]["output"]>;
+};
+export type SchemaExternalDocs = {
+    __typename?: "SchemaExternalDocs";
+    description?: Maybe<Scalars["String"]["output"]>;
+    url: Scalars["String"]["output"];
+};
+export type SchemaItem = {
+    __typename?: "SchemaItem";
+    extensions?: Maybe<Scalars["JSONObject"]["output"]>;
+    name: Scalars["String"]["output"];
+    schema: Scalars["JSONSchema"]["output"];
+};
+export type SchemaLicense = {
+    __typename?: "SchemaLicense";
+    identifier?: Maybe<Scalars["String"]["output"]>;
+    name: Scalars["String"]["output"];
+    url?: Maybe<Scalars["String"]["output"]>;
+};
+export type SchemaTag = {
+    __typename?: "SchemaTag";
+    description?: Maybe<Scalars["String"]["output"]>;
+    extensions?: Maybe<Scalars["JSONObject"]["output"]>;
+    isUntagged: Scalars["Boolean"]["output"];
+    name?: Maybe<Scalars["String"]["output"]>;
+    next?: Maybe<SchemaTag>;
+    operations: Array<OperationItem>;
+    prev?: Maybe<SchemaTag>;
+    slug?: Maybe<Scalars["String"]["output"]>;
+};
+export type SchemaType = "file" | "raw" | "url";
+export type Server = {
+    __typename?: "Server";
+    description?: Maybe<Scalars["String"]["output"]>;
+    url: Scalars["String"]["output"];
+};
+export type TagItem = {
+    __typename?: "TagItem";
+    description?: Maybe<Scalars["String"]["output"]>;
+    extensions?: Maybe<Scalars["JSONObject"]["output"]>;
+    name: Scalars["String"]["output"];
+};
+export type WebhookItem = {
+    __typename?: "WebhookItem";
+    description?: Maybe<Scalars["String"]["output"]>;
+    method: Scalars["String"]["output"];
+    name: Scalars["String"]["output"];
+    operationId?: Maybe<Scalars["String"]["output"]>;
+    summary?: Maybe<Scalars["String"]["output"]>;
+};
+export type ServersQueryQueryVariables = Exact<{
+    input: Scalars["JSON"]["input"];
+    type: SchemaType;
+}>;
+export type ServersQueryQuery = {
+    __typename?: "Query";
+    schema: {
+        __typename?: "Schema";
+        url?: string | null;
+        servers: Array<{
+            __typename?: "Server";
+            url: string;
+        }>;
+    };
+};
+export type OperationsFragmentFragment = {
+    __typename?: "OperationItem";
+    slug: string;
+    summary?: string | null;
+    method: string;
+    description?: string | null;
+    operationId?: string | null;
+    contentTypes: Array<string>;
+    path: string;
+    deprecated?: boolean | null;
+    extensions?: any | null;
+    servers: Array<{
+        __typename?: "Server";
+        url: string;
+        description?: string | null;
+    }>;
+    parameters?: Array<{
+        __typename?: "ParameterItem";
+        name: string;
+        in: ParameterIn;
+        description?: string | null;
+        required?: boolean | null;
+        schema?: any | null;
+        style?: string | null;
+        explode?: boolean | null;
+        allowReserved?: boolean | null;
+        examples?: Array<{
+            __typename?: "ExampleItem";
+            name: string;
+            description?: string | null;
+            externalValue?: string | null;
+            value?: any | null;
+            summary?: string | null;
+        }> | null;
+    }> | null;
+    requestBody?: {
+        __typename?: "RequestBodyObject";
+        description?: string | null;
+        required?: boolean | null;
+        content?: Array<{
+            __typename?: "MediaTypeObject";
+            mediaType: string;
+            schema?: any | null;
+            encoding?: Array<{
+                __typename?: "EncodingItem";
+                name: string;
+            }> | null;
+            examples?: Array<{
+                __typename?: "ExampleItem";
+                name: string;
+                description?: string | null;
+                externalValue?: string | null;
+                value?: any | null;
+                summary?: string | null;
+            }> | null;
+        }> | null;
+    } | null;
+    responses: Array<{
+        __typename?: "ResponseItem";
+        statusCode: string;
+        links?: any | null;
+        description?: string | null;
+        content?: Array<{
+            __typename?: "MediaTypeObject";
+            mediaType: string;
+            schema?: any | null;
+            examples?: Array<{
+                __typename?: "ExampleItem";
+                name: string;
+                description?: string | null;
+                externalValue?: string | null;
+                value?: any | null;
+                summary?: string | null;
+            }> | null;
+            encoding?: Array<{
+                __typename?: "EncodingItem";
+                name: string;
+            }> | null;
+        }> | null;
+    }>;
+} & {
+    " $fragmentName"?: "OperationsFragmentFragment";
+};
+export type OperationsForTagQueryVariables = Exact<{
+    input: Scalars["JSON"]["input"];
+    type: SchemaType;
+    tag?: InputMaybe<Scalars["String"]["input"]>;
+    untagged?: InputMaybe<Scalars["Boolean"]["input"]>;
+}>;
+export type OperationsForTagQuery = {
+    __typename?: "Query";
+    schema: {
+        __typename?: "Schema";
+        description?: string | null;
+        summary?: string | null;
+        title: string;
+        url?: string | null;
+        version: string;
+        servers: Array<{
+            __typename?: "Server";
+            url: string;
+        }>;
+        tag?: {
+            __typename?: "SchemaTag";
+            name?: string | null;
+            description?: string | null;
+            extensions?: any | null;
+            operations: Array<{
+                __typename?: "OperationItem";
+                slug: string;
+            } & {
+                " $fragmentRefs"?: {
+                    OperationsFragmentFragment: OperationsFragmentFragment;
+                };
+            }>;
+            next?: {
+                __typename?: "SchemaTag";
+                name?: string | null;
+                slug?: string | null;
+                extensions?: any | null;
+            } | null;
+            prev?: {
+                __typename?: "SchemaTag";
+                name?: string | null;
+                slug?: string | null;
+                extensions?: any | null;
+            } | null;
+        } | null;
+    };
+};
+export type SchemaInfoQueryVariables = Exact<{
+    input: Scalars["JSON"]["input"];
+    type: SchemaType;
+}>;
+export type SchemaInfoQuery = {
+    __typename?: "Query";
+    schema: {
+        __typename?: "Schema";
+        termsOfService?: string | null;
+        description?: string | null;
+        summary?: string | null;
+        title: string;
+        url?: string | null;
+        version: string;
+        servers: Array<{
+            __typename?: "Server";
+            url: string;
+            description?: string | null;
+        }>;
+        license?: {
+            __typename?: "SchemaLicense";
+            name: string;
+            url?: string | null;
+            identifier?: string | null;
+        } | null;
+        externalDocs?: {
+            __typename?: "SchemaExternalDocs";
+            description?: string | null;
+            url: string;
+        } | null;
+        contact?: {
+            __typename?: "SchemaContact";
+            name?: string | null;
+            url?: string | null;
+            email?: string | null;
+        } | null;
+        tags: Array<{
+            __typename?: "SchemaTag";
+            name?: string | null;
+            description?: string | null;
+        }>;
+        components?: {
+            __typename?: "Components";
+            schemas?: Array<{
+                __typename?: "SchemaItem";
+                name: string;
+            }> | null;
+        } | null;
+        webhooks: Array<{
+            __typename?: "WebhookItem";
+            name: string;
+            method: string;
+            summary?: string | null;
+            description?: string | null;
+        }>;
+    };
+};
+export type GetSchemasQueryVariables = Exact<{
+    input: Scalars["JSON"]["input"];
+    type: SchemaType;
+}>;
+export type GetSchemasQuery = {
+    __typename?: "Query";
+    schema: {
+        __typename?: "Schema";
+        title: string;
+        description?: string | null;
+        summary?: string | null;
+        components?: {
+            __typename?: "Components";
+            schemas?: Array<{
+                __typename?: "SchemaItem";
+                name: string;
+                schema: any;
+                extensions?: any | null;
+            }> | null;
+        } | null;
+    };
+};
+export type GetServerQueryQueryVariables = Exact<{
+    input: Scalars["JSON"]["input"];
+    type: SchemaType;
+}>;
+export type GetServerQueryQuery = {
+    __typename?: "Query";
+    schema: {
+        __typename?: "Schema";
+        url?: string | null;
+        servers: Array<{
+            __typename?: "Server";
+            url: string;
+        }>;
+    };
+};
+export type GetNavigationOperationsQueryVariables = Exact<{
+    input: Scalars["JSON"]["input"];
+    type: SchemaType;
+}>;
+export type GetNavigationOperationsQuery = {
+    __typename?: "Query";
+    schema: {
+        __typename?: "Schema";
+        extensions?: any | null;
+        tags: Array<{
+            __typename?: "SchemaTag";
+            slug?: string | null;
+            name?: string | null;
+            extensions?: any | null;
+            operations: Array<{
+                __typename?: "OperationItem";
+                summary?: string | null;
+                slug: string;
+                method: string;
+                operationId?: string | null;
+                path: string;
+            }>;
+        }>;
+        components?: {
+            __typename?: "Components";
+            schemas?: Array<{
+                __typename: "SchemaItem";
+            }> | null;
+        } | null;
+    };
+};
+export type SchemaWarmupQueryVariables = Exact<{
+    input: Scalars["JSON"]["input"];
+    type: SchemaType;
+}>;
+export type SchemaWarmupQuery = {
+    __typename?: "Query";
+    schema: {
+        __typename?: "Schema";
+        openapi: string;
+    };
+};
+export declare class TypedDocumentString<TResult, TVariables> extends String implements DocumentTypeDecoration<TResult, TVariables> {
+    __apiType?: NonNullable<DocumentTypeDecoration<TResult, TVariables>["__apiType"]>;
+    private value;
+    __meta__?: Record<string, any> | undefined;
+    constructor(value: string, __meta__?: Record<string, any> | undefined);
+    toString(): string & DocumentTypeDecoration<TResult, TVariables>;
+}
+export declare const OperationsFragmentFragmentDoc: TypedDocumentString<OperationsFragmentFragment, unknown>;
+export declare const ServersQueryDocument: TypedDocumentString<ServersQueryQuery, ServersQueryQueryVariables>;
+export declare const OperationsForTagDocument: TypedDocumentString<OperationsForTagQuery, OperationsForTagQueryVariables>;
+export declare const SchemaInfoDocument: TypedDocumentString<SchemaInfoQuery, SchemaInfoQueryVariables>;
+export declare const GetSchemasDocument: TypedDocumentString<GetSchemasQuery, GetSchemasQueryVariables>;
+export declare const GetServerQueryDocument: TypedDocumentString<GetServerQueryQuery, GetServerQueryQueryVariables>;
+export declare const GetNavigationOperationsDocument: TypedDocumentString<GetNavigationOperationsQuery, GetNavigationOperationsQueryVariables>;
+export declare const SchemaWarmupDocument: TypedDocumentString<SchemaWarmupQuery, SchemaWarmupQueryVariables>;

package/dist/declarations/lib/plugins/openapi/graphql/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./fragment-masking.js";
+export * from "./gql.js";

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

@@ -0,0 +1,11 @@
+import type { ApitogoPlugin } from "../../core/plugins.js";
+import type { GetNavigationOperationsQuery as GetNavigationOperationsQueryResult } from "./graphql/graphql.js";
+import type { OasPluginConfig } from "./interfaces.js";
+export declare const GetNavigationOperationsQuery: import("./graphql/graphql.js").TypedDocumentString<GetNavigationOperationsQueryResult, import("./graphql/graphql.js").Exact<{
+    input: import("./graphql/graphql.js").Scalars["JSON"]["input"];
+    type: import("./graphql/graphql.js").SchemaType;
+}>>;
+export type OperationResult = GetNavigationOperationsQueryResult["schema"]["tags"][number]["operations"][number];
+export type OpenApiPluginOptions = OasPluginConfig;
+export declare const UNTAGGED_PATH = "~endpoints";
+export declare const openApiPlugin: (config: OasPluginConfig) => ApitogoPlugin;

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

@@ -0,0 +1,94 @@
+import type { AuthState } from "../../authentication/state.js";
+import type { ZudokuContext } from "../../core/ZudokuContext.js";
+import type { SchemaImports } from "../../oas/graphql/index.js";
+import type { OperationsFragmentFragment } from "./graphql/graphql.js";
+type DynamicInput = () => Promise<unknown>;
+export type VersionedInput<T = string> = {
+    path: string;
+    version?: string;
+    downloadUrl?: string;
+    label?: string;
+    input: T;
+    hasUntaggedOperations?: boolean;
+    tagPages?: string[];
+};
+type OasSource = {
+    type: "url";
+    input: string | VersionedInput[];
+} | {
+    type: "file";
+    input: VersionedInput<DynamicInput>[];
+} | {
+    type: "raw";
+    input: string;
+};
+export type ContextOasSource = {
+    type: "url" | "file" | "raw";
+    input: string | DynamicInput;
+};
+type Example = {
+    name: string;
+    description?: string | null;
+    externalValue?: string | null;
+    value?: any | null;
+    summary?: string | null;
+};
+type Content = {
+    mediaType: string;
+    schema?: any | null;
+    encoding?: Array<{
+        name: string;
+    }> | null;
+    examples?: Array<Example> | null;
+};
+export type TransformExamplesFn = (options: {
+    content: Content[];
+    context: ZudokuContext;
+    auth: AuthState;
+    operation: OperationsFragmentFragment;
+    type: "request" | "response";
+}) => Content[];
+export type GenerateCodeSnippetFn = (options: {
+    selectedLang: string;
+    selectedServer: string;
+    context: ZudokuContext;
+    auth: AuthState;
+    operation: OperationsFragmentFragment;
+    example?: any | null;
+}) => string | false;
+type BaseOasConfig = {
+    server?: string;
+    path?: string;
+    skipPreload?: boolean;
+    tagPages?: Array<string>;
+    schemaImports?: SchemaImports;
+    options?: {
+        examplesLanguage?: string;
+        supportedLanguages?: {
+            value: string;
+            label: string;
+        }[];
+        disablePlayground?: boolean;
+        disableSidecar?: boolean;
+        showVersionSelect?: "always" | "if-available" | "hide";
+        expandAllTags?: boolean;
+        showInfoPage?: boolean;
+        schemaDownload?: {
+            enabled: boolean;
+        };
+        transformExamples?: TransformExamplesFn;
+        generateCodeSnippet?: GenerateCodeSnippetFn;
+    };
+};
+export type OasPluginConfig = BaseOasConfig & OasSource;
+export type VersionEntry = {
+    path: string;
+    label: string;
+    downloadUrl?: string;
+    tagPages?: string[];
+};
+export type OasPluginContext = BaseOasConfig & ContextOasSource & {
+    version?: string;
+    versions: Record<string, VersionEntry>;
+};
+export {};

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

@@ -0,0 +1,5 @@
+import type { MediaTypeObject } from "../graphql/graphql.js";
+export declare const BodyPanel: ({ content }: {
+    content?: MediaTypeObject[];
+}) => import("react/jsx-runtime").JSX.Element;
+export default BodyPanel;

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

@@ -0,0 +1,8 @@
+export declare const CollapsibleHeaderTrigger: ({ children, className, }: {
+    children: React.ReactNode;
+    className?: string;
+}) => import("react/jsx-runtime").JSX.Element;
+export declare const CollapsibleHeader: ({ children, className, }: {
+    children: React.ReactNode;
+    className?: string;
+}) => import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,6 @@
+import type { ExampleItem, MediaTypeObject } from "../graphql/graphql.js";
+declare const ExamplesDropdown: ({ examples, onSelect, }: {
+    examples: MediaTypeObject[];
+    onSelect: (example: ExampleItem, mediaType: string) => void;
+}) => import("react/jsx-runtime").JSX.Element;
+export default ExamplesDropdown;

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

@@ -0,0 +1,7 @@
+import { type Control } from "react-hook-form";
+import type { Header, PlaygroundForm } from "./Playground.js";
+export declare const Headers: ({ control, schemaHeaders, lockedHeaders, }: {
+    control: Control<PlaygroundForm>;
+    schemaHeaders: Header[];
+    lockedHeaders?: string[];
+}) => import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,11 @@
+import type { ApiIdentity } from "../../../core/ZudokuContext.js";
+declare const IdentityDialog: ({ onSubmit, identities, open, onOpenChange, }: {
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    onSubmit: ({ rememberedIdentity, identity, }: {
+        rememberedIdentity: boolean;
+        identity?: string;
+    }) => void;
+    identities: ApiIdentity[];
+}) => import("react/jsx-runtime").JSX.Element;
+export { IdentityDialog };

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

@@ -0,0 +1,7 @@
+import type { ApiIdentity } from "../../../core/ZudokuContext.js";
+declare const IdentitySelector: ({ identities, setValue, value, }: {
+    identities?: ApiIdentity[];
+    setValue: (value: string) => void;
+    value?: string;
+}) => import("react/jsx-runtime").JSX.Element;
+export default IdentitySelector;