apiuikit 0.3.0 → 1.0.0

package/dist/csharp-AnFv7wyC.js

@@ -0,0 +1,382 @@
+function C(e) {
+  const d = [
+    "bool",
+    "byte",
+    "char",
+    "decimal",
+    "delegate",
+    "double",
+    "dynamic",
+    "enum",
+    "float",
+    "int",
+    "long",
+    "nint",
+    "nuint",
+    "object",
+    "sbyte",
+    "short",
+    "string",
+    "ulong",
+    "uint",
+    "ushort"
+  ], l = [
+    "public",
+    "private",
+    "protected",
+    "static",
+    "internal",
+    "protected",
+    "abstract",
+    "async",
+    "extern",
+    "override",
+    "unsafe",
+    "virtual",
+    "new",
+    "sealed",
+    "partial"
+  ], g = [
+    "default",
+    "false",
+    "null",
+    "true"
+  ], O = [
+    "abstract",
+    "as",
+    "base",
+    "break",
+    "case",
+    "catch",
+    "class",
+    "const",
+    "continue",
+    "do",
+    "else",
+    "event",
+    "explicit",
+    "extern",
+    "finally",
+    "fixed",
+    "for",
+    "foreach",
+    "goto",
+    "if",
+    "implicit",
+    "in",
+    "interface",
+    "internal",
+    "is",
+    "lock",
+    "namespace",
+    "new",
+    "operator",
+    "out",
+    "override",
+    "params",
+    "private",
+    "protected",
+    "public",
+    "readonly",
+    "record",
+    "ref",
+    "return",
+    "scoped",
+    "sealed",
+    "sizeof",
+    "stackalloc",
+    "static",
+    "struct",
+    "switch",
+    "this",
+    "throw",
+    "try",
+    "typeof",
+    "unchecked",
+    "unsafe",
+    "using",
+    "virtual",
+    "void",
+    "volatile",
+    "while"
+  ], N = [
+    "add",
+    "alias",
+    "and",
+    "ascending",
+    "args",
+    "async",
+    "await",
+    "by",
+    "descending",
+    "dynamic",
+    "equals",
+    "file",
+    "from",
+    "get",
+    "global",
+    "group",
+    "init",
+    "into",
+    "join",
+    "let",
+    "nameof",
+    "not",
+    "notnull",
+    "on",
+    "or",
+    "orderby",
+    "partial",
+    "record",
+    "remove",
+    "required",
+    "scoped",
+    "select",
+    "set",
+    "unmanaged",
+    "value|0",
+    "var",
+    "when",
+    "where",
+    "with",
+    "yield"
+  ], n = {
+    keyword: O.concat(N),
+    built_in: d,
+    literal: g
+  }, a = e.inherit(e.TITLE_MODE, { begin: "[a-zA-Z](\\.?\\w)*" }), i = {
+    className: "number",
+    variants: [
+      { begin: "\\b(0b[01']+)" },
+      { begin: "(-?)\\b([\\d']+(\\.[\\d']*)?|\\.[\\d']+)(u|U|l|L|ul|UL|f|F|b|B)" },
+      { begin: "(-?)(\\b0[xX][a-fA-F0-9']+|(\\b[\\d']+(\\.[\\d']*)?|\\.[\\d']+)([eE][-+]?[\\d']+)?)" }
+    ],
+    relevance: 0
+  }, T = {
+    className: "string",
+    begin: /"""("*)(?!")(.|\n)*?"""\1/,
+    relevance: 1
+  }, t = {
+    className: "string",
+    begin: '@"',
+    end: '"',
+    contains: [{ begin: '""' }]
+  }, b = e.inherit(t, { illegal: /\n/ }), r = {
+    className: "subst",
+    begin: /\{/,
+    end: /\}/,
+    keywords: n
+  }, c = e.inherit(r, { illegal: /\n/ }), s = {
+    className: "string",
+    begin: /\$"/,
+    end: '"',
+    illegal: /\n/,
+    contains: [
+      { begin: /\{\{/ },
+      { begin: /\}\}/ },
+      e.BACKSLASH_ESCAPE,
+      c
+    ]
+  }, o = {
+    className: "string",
+    begin: /\$@"/,
+    end: '"',
+    contains: [
+      { begin: /\{\{/ },
+      { begin: /\}\}/ },
+      { begin: '""' },
+      r
+    ]
+  }, M = e.inherit(o, {
+    illegal: /\n/,
+    contains: [
+      { begin: /\{\{/ },
+      { begin: /\}\}/ },
+      { begin: '""' },
+      c
+    ]
+  });
+  r.contains = [
+    o,
+    s,
+    t,
+    e.APOS_STRING_MODE,
+    e.QUOTE_STRING_MODE,
+    i,
+    e.C_BLOCK_COMMENT_MODE
+  ], c.contains = [
+    M,
+    s,
+    b,
+    e.APOS_STRING_MODE,
+    e.QUOTE_STRING_MODE,
+    i,
+    e.inherit(e.C_BLOCK_COMMENT_MODE, { illegal: /\n/ })
+  ];
+  const _ = { variants: [
+    T,
+    o,
+    s,
+    t,
+    e.APOS_STRING_MODE,
+    e.QUOTE_STRING_MODE
+  ] }, E = {
+    begin: "<",
+    end: ">",
+    contains: [
+      { beginKeywords: "in out" },
+      a
+    ]
+  }, u = e.IDENT_RE + "(<" + e.IDENT_RE + "(\\s*,\\s*" + e.IDENT_RE + ")*>)?(\\[\\])?", I = {
+    // prevents expressions like `@class` from incorrect flagging
+    // `class` as a keyword
+    begin: "@" + e.IDENT_RE,
+    relevance: 0
+  };
+  return {
+    name: "C#",
+    aliases: [
+      "cs",
+      "c#"
+    ],
+    keywords: n,
+    illegal: /::/,
+    contains: [
+      e.COMMENT(
+        "///",
+        "$",
+        {
+          returnBegin: !0,
+          contains: [
+            {
+              className: "doctag",
+              variants: [
+                {
+                  begin: "///",
+                  relevance: 0
+                },
+                { begin: "<!--|-->" },
+                {
+                  begin: "</?",
+                  end: ">"
+                }
+              ]
+            }
+          ]
+        }
+      ),
+      e.C_LINE_COMMENT_MODE,
+      e.C_BLOCK_COMMENT_MODE,
+      {
+        className: "meta",
+        begin: "#",
+        end: "$",
+        keywords: { keyword: "if else elif endif define undef warning error line region endregion pragma checksum" }
+      },
+      _,
+      i,
+      {
+        beginKeywords: "class interface",
+        relevance: 0,
+        end: /[{;=]/,
+        illegal: /[^\s:,]/,
+        contains: [
+          { beginKeywords: "where class" },
+          a,
+          E,
+          e.C_LINE_COMMENT_MODE,
+          e.C_BLOCK_COMMENT_MODE
+        ]
+      },
+      {
+        beginKeywords: "namespace",
+        relevance: 0,
+        end: /[{;=]/,
+        illegal: /[^\s:]/,
+        contains: [
+          a,
+          e.C_LINE_COMMENT_MODE,
+          e.C_BLOCK_COMMENT_MODE
+        ]
+      },
+      {
+        beginKeywords: "record",
+        relevance: 0,
+        end: /[{;=]/,
+        illegal: /[^\s:]/,
+        contains: [
+          a,
+          E,
+          e.C_LINE_COMMENT_MODE,
+          e.C_BLOCK_COMMENT_MODE
+        ]
+      },
+      {
+        // [Attributes("")]
+        className: "meta",
+        begin: "^\\s*\\[(?=[\\w])",
+        excludeBegin: !0,
+        end: "\\]",
+        excludeEnd: !0,
+        contains: [
+          {
+            className: "string",
+            begin: /"/,
+            end: /"/
+          }
+        ]
+      },
+      {
+        // Expression keywords prevent 'keyword Name(...)' from being
+        // recognized as a function definition
+        beginKeywords: "new return throw await else",
+        relevance: 0
+      },
+      {
+        className: "function",
+        begin: "(" + u + "\\s+)+" + e.IDENT_RE + "\\s*(<[^=]+>\\s*)?\\(",
+        returnBegin: !0,
+        end: /\s*[{;=]/,
+        excludeEnd: !0,
+        keywords: n,
+        contains: [
+          // prevents these from being highlighted `title`
+          {
+            beginKeywords: l.join(" "),
+            relevance: 0
+          },
+          {
+            begin: e.IDENT_RE + "\\s*(<[^=]+>\\s*)?\\(",
+            returnBegin: !0,
+            contains: [
+              e.TITLE_MODE,
+              E
+            ],
+            relevance: 0
+          },
+          { match: /\(\)/ },
+          {
+            className: "params",
+            begin: /\(/,
+            end: /\)/,
+            excludeBegin: !0,
+            excludeEnd: !0,
+            keywords: n,
+            relevance: 0,
+            contains: [
+              _,
+              i,
+              e.C_BLOCK_COMMENT_MODE
+            ]
+          },
+          e.C_LINE_COMMENT_MODE,
+          e.C_BLOCK_COMMENT_MODE
+        ]
+      },
+      I
+    ]
+  };
+}
+export {
+  C as default
+};

package/dist/csharp-yuAGIuP4.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});function C(e){const d=["bool","byte","char","decimal","delegate","double","dynamic","enum","float","int","long","nint","nuint","object","sbyte","short","string","ulong","uint","ushort"],l=["public","private","protected","static","internal","protected","abstract","async","extern","override","unsafe","virtual","new","sealed","partial"],g=["default","false","null","true"],O=["abstract","as","base","break","case","catch","class","const","continue","do","else","event","explicit","extern","finally","fixed","for","foreach","goto","if","implicit","in","interface","internal","is","lock","namespace","new","operator","out","override","params","private","protected","public","readonly","record","ref","return","scoped","sealed","sizeof","stackalloc","static","struct","switch","this","throw","try","typeof","unchecked","unsafe","using","virtual","void","volatile","while"],N=["add","alias","and","ascending","args","async","await","by","descending","dynamic","equals","file","from","get","global","group","init","into","join","let","nameof","not","notnull","on","or","orderby","partial","record","remove","required","scoped","select","set","unmanaged","value|0","var","when","where","with","yield"],n={keyword:O.concat(N),built_in:d,literal:g},i=e.inherit(e.TITLE_MODE,{begin:"[a-zA-Z](\\.?\\w)*"}),a={className:"number",variants:[{begin:"\\b(0b[01']+)"},{begin:"(-?)\\b([\\d']+(\\.[\\d']*)?|\\.[\\d']+)(u|U|l|L|ul|UL|f|F|b|B)"},{begin:"(-?)(\\b0[xX][a-fA-F0-9']+|(\\b[\\d']+(\\.[\\d']*)?|\\.[\\d']+)([eE][-+]?[\\d']+)?)"}],relevance:0},T={className:"string",begin:/"""("*)(?!")(.|\n)*?"""\1/,relevance:1},t={className:"string",begin:'@"',end:'"',contains:[{begin:'""'}]},b=e.inherit(t,{illegal:/\n/}),r={className:"subst",begin:/\{/,end:/\}/,keywords:n},c=e.inherit(r,{illegal:/\n/}),s={className:"string",begin:/\$"/,end:'"',illegal:/\n/,contains:[{begin:/\{\{/},{begin:/\}\}/},e.BACKSLASH_ESCAPE,c]},o={className:"string",begin:/\$@"/,end:'"',contains:[{begin:/\{\{/},{begin:/\}\}/},{begin:'""'},r]},u=e.inherit(o,{illegal:/\n/,contains:[{begin:/\{\{/},{begin:/\}\}/},{begin:'""'},c]});r.contains=[o,s,t,e.APOS_STRING_MODE,e.QUOTE_STRING_MODE,a,e.C_BLOCK_COMMENT_MODE],c.contains=[u,s,b,e.APOS_STRING_MODE,e.QUOTE_STRING_MODE,a,e.inherit(e.C_BLOCK_COMMENT_MODE,{illegal:/\n/})];const _={variants:[T,o,s,t,e.APOS_STRING_MODE,e.QUOTE_STRING_MODE]},E={begin:"<",end:">",contains:[{beginKeywords:"in out"},i]},M=e.IDENT_RE+"(<"+e.IDENT_RE+"(\\s*,\\s*"+e.IDENT_RE+")*>)?(\\[\\])?",I={begin:"@"+e.IDENT_RE,relevance:0};return{name:"C#",aliases:["cs","c#"],keywords:n,illegal:/::/,contains:[e.COMMENT("///","$",{returnBegin:!0,contains:[{className:"doctag",variants:[{begin:"///",relevance:0},{begin:"<!--|-->"},{begin:"</?",end:">"}]}]}),e.C_LINE_COMMENT_MODE,e.C_BLOCK_COMMENT_MODE,{className:"meta",begin:"#",end:"$",keywords:{keyword:"if else elif endif define undef warning error line region endregion pragma checksum"}},_,a,{beginKeywords:"class interface",relevance:0,end:/[{;=]/,illegal:/[^\s:,]/,contains:[{beginKeywords:"where class"},i,E,e.C_LINE_COMMENT_MODE,e.C_BLOCK_COMMENT_MODE]},{beginKeywords:"namespace",relevance:0,end:/[{;=]/,illegal:/[^\s:]/,contains:[i,e.C_LINE_COMMENT_MODE,e.C_BLOCK_COMMENT_MODE]},{beginKeywords:"record",relevance:0,end:/[{;=]/,illegal:/[^\s:]/,contains:[i,E,e.C_LINE_COMMENT_MODE,e.C_BLOCK_COMMENT_MODE]},{className:"meta",begin:"^\\s*\\[(?=[\\w])",excludeBegin:!0,end:"\\]",excludeEnd:!0,contains:[{className:"string",begin:/"/,end:/"/}]},{beginKeywords:"new return throw await else",relevance:0},{className:"function",begin:"("+M+"\\s+)+"+e.IDENT_RE+"\\s*(<[^=]+>\\s*)?\\(",returnBegin:!0,end:/\s*[{;=]/,excludeEnd:!0,keywords:n,contains:[{beginKeywords:l.join(" "),relevance:0},{begin:e.IDENT_RE+"\\s*(<[^=]+>\\s*)?\\(",returnBegin:!0,contains:[e.TITLE_MODE,E],relevance:0},{match:/\(\)/},{className:"params",begin:/\(/,end:/\)/,excludeBegin:!0,excludeEnd:!0,keywords:n,relevance:0,contains:[_,a,e.C_BLOCK_COMMENT_MODE]},e.C_LINE_COMMENT_MODE,e.C_BLOCK_COMMENT_MODE]},I]}}exports.default=C;

package/dist/go-BpetKc7b.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});function t(e){const n={keyword:["break","case","chan","const","continue","default","defer","else","fallthrough","for","func","go","goto","if","import","interface","map","package","range","return","select","struct","switch","type","var"],type:["bool","byte","complex64","complex128","error","float32","float64","int8","int16","int32","int64","string","uint8","uint16","uint32","uint64","int","uint","uintptr","rune"],literal:["true","false","iota","nil"],built_in:["append","cap","close","complex","copy","imag","len","make","new","panic","print","println","real","recover","delete"]};return{name:"Go",aliases:["golang"],keywords:n,illegal:"</",contains:[e.C_LINE_COMMENT_MODE,e.C_BLOCK_COMMENT_MODE,{className:"string",variants:[e.QUOTE_STRING_MODE,e.APOS_STRING_MODE,{begin:"`",end:"`"}]},{className:"number",variants:[{match:/-?\b0[xX]\.[a-fA-F0-9](_?[a-fA-F0-9])*[pP][+-]?\d(_?\d)*i?/,relevance:0},{match:/-?\b0[xX](_?[a-fA-F0-9])+((\.([a-fA-F0-9](_?[a-fA-F0-9])*)?)?[pP][+-]?\d(_?\d)*)?i?/,relevance:0},{match:/-?\b0[oO](_?[0-7])*i?/,relevance:0},{match:/-?\.\d(_?\d)*([eE][+-]?\d(_?\d)*)?i?/,relevance:0},{match:/-?\b\d(_?\d)*(\.(\d(_?\d)*)?)?([eE][+-]?\d(_?\d)*)?i?/,relevance:0}]},{begin:/:=/},{className:"function",beginKeywords:"func",end:"\\s*(\\{|$)",excludeEnd:!0,contains:[e.TITLE_MODE,{className:"params",begin:/\(/,end:/\)/,endsParent:!0,keywords:n,illegal:/["']/}]}]}}exports.default=t;

package/dist/go-CkZ9_bn0.js

@@ -0,0 +1,151 @@
+function c(e) {
+  const n = {
+    keyword: [
+      "break",
+      "case",
+      "chan",
+      "const",
+      "continue",
+      "default",
+      "defer",
+      "else",
+      "fallthrough",
+      "for",
+      "func",
+      "go",
+      "goto",
+      "if",
+      "import",
+      "interface",
+      "map",
+      "package",
+      "range",
+      "return",
+      "select",
+      "struct",
+      "switch",
+      "type",
+      "var"
+    ],
+    type: [
+      "bool",
+      "byte",
+      "complex64",
+      "complex128",
+      "error",
+      "float32",
+      "float64",
+      "int8",
+      "int16",
+      "int32",
+      "int64",
+      "string",
+      "uint8",
+      "uint16",
+      "uint32",
+      "uint64",
+      "int",
+      "uint",
+      "uintptr",
+      "rune"
+    ],
+    literal: [
+      "true",
+      "false",
+      "iota",
+      "nil"
+    ],
+    built_in: [
+      "append",
+      "cap",
+      "close",
+      "complex",
+      "copy",
+      "imag",
+      "len",
+      "make",
+      "new",
+      "panic",
+      "print",
+      "println",
+      "real",
+      "recover",
+      "delete"
+    ]
+  };
+  return {
+    name: "Go",
+    aliases: ["golang"],
+    keywords: n,
+    illegal: "</",
+    contains: [
+      e.C_LINE_COMMENT_MODE,
+      e.C_BLOCK_COMMENT_MODE,
+      {
+        className: "string",
+        variants: [
+          e.QUOTE_STRING_MODE,
+          e.APOS_STRING_MODE,
+          {
+            begin: "`",
+            end: "`"
+          }
+        ]
+      },
+      {
+        className: "number",
+        variants: [
+          {
+            match: /-?\b0[xX]\.[a-fA-F0-9](_?[a-fA-F0-9])*[pP][+-]?\d(_?\d)*i?/,
+            // hex without a present digit before . (making a digit afterwards required)
+            relevance: 0
+          },
+          {
+            match: /-?\b0[xX](_?[a-fA-F0-9])+((\.([a-fA-F0-9](_?[a-fA-F0-9])*)?)?[pP][+-]?\d(_?\d)*)?i?/,
+            // hex with a present digit before . (making a digit afterwards optional)
+            relevance: 0
+          },
+          {
+            match: /-?\b0[oO](_?[0-7])*i?/,
+            // leading 0o octal
+            relevance: 0
+          },
+          {
+            match: /-?\.\d(_?\d)*([eE][+-]?\d(_?\d)*)?i?/,
+            // decimal without a present digit before . (making a digit afterwards required)
+            relevance: 0
+          },
+          {
+            match: /-?\b\d(_?\d)*(\.(\d(_?\d)*)?)?([eE][+-]?\d(_?\d)*)?i?/,
+            // decimal with a present digit before . (making a digit afterwards optional)
+            relevance: 0
+          }
+        ]
+      },
+      {
+        begin: /:=/
+        // relevance booster
+      },
+      {
+        className: "function",
+        beginKeywords: "func",
+        end: "\\s*(\\{|$)",
+        excludeEnd: !0,
+        contains: [
+          e.TITLE_MODE,
+          {
+            className: "params",
+            begin: /\(/,
+            end: /\)/,
+            endsParent: !0,
+            keywords: n,
+            illegal: /["']/
+          }
+        ]
+      }
+    ]
+  };
+}
+export {
+  c as default
+};

package/dist/helpers/codeSamples.d.ts

@@ -0,0 +1,92 @@
+import { availableTargets } from '@readme/httpsnippet';
+import { HttpMethod, OpenAPIParameterData, OpenAPIRequestBodyData, OpenAPISecuritySchemeData, OpenAPIServerData } from '../types/openapi';
+export declare const DEFAULT_CODE_SAMPLE_TARGET = "shell";
+export declare const DEFAULT_CODE_SAMPLE_CLIENT = "curl";
+export type AvailableCodeSampleTarget = ReturnType<typeof availableTargets>[number];
+/** Every target/client @readme/httpsnippet knows how to generate (curl,
+ * fetch, axios, Python requests, Go, Rust, ...), grouped by target — this is
+ * the data source for the language/library dropdown. Pure passthrough kept
+ * here so `@readme/httpsnippet` stays imported in one place. */
+export declare function getAvailableCodeSampleTargets(): AvailableCodeSampleTarget[];
+interface HarNameValue {
+    name: string;
+    value: string;
+}
+/** Loosely-typed HAR request we build ourselves — @readme/httpsnippet's own
+ * `HarRequest` type (from @types/har-format) declares several fields as
+ * required that its `init()` step actually defaults for us at runtime
+ * (httpVersion, headers, cookies, queryString, postData.mimeType). We build
+ * only what we need and cast at the single call site in `generateSnippet`. */
+export interface CodeSampleHarRequest {
+    method: string;
+    url: string;
+    httpVersion: string;
+    headers: HarNameValue[];
+    queryString: HarNameValue[];
+    cookies: HarNameValue[];
+    postData?: {
+        mimeType: string;
+        text: string;
+    };
+}
+interface ResolvedAuthPlaceholder {
+    location: "header" | "query" | "cookie";
+    name: string;
+    value: string;
+}
+interface ResolvedRequestBodyMedia {
+    contentType: string;
+    schema?: unknown;
+    authorExample?: unknown;
+}
+/** Substitutes each `{var}` in a server URL template with its declared
+ * default (or first enum value, or the literal token as a last resort).
+ * Falls back to a placeholder host when the operation has no server at all,
+ * since HTTPSnippet's clients require an absolute URL. */
+export declare function resolveServerBaseUrl(servers?: OpenAPIServerData[]): string;
+/** Precedence: `param.example` → first `param.examples[...].value` →
+ * `schema.example` → first `schema.enum` value → a literal `{name}` token as
+ * a last-resort placeholder, so an undocumented parameter still produces a
+ * valid, copyable (if not runnable as-is) sample. */
+export declare function resolveParamExampleValue(param: OpenAPIParameterData): string;
+/** Substitutes `{token}` path placeholders using the matching `in: "path"`
+ * parameter's example value. Falls back to the literal token when no
+ * matching parameter is supplied — this is what keeps the sample valid even
+ * for operations whose path parameter is only declared at the path-item
+ * level (not merged into `op.parameters` today). */
+export declare function buildRequestUrl(baseUrl: string, path: string, parameters: OpenAPIParameterData[]): string;
+/** Resolves the first `security`/`globalSecurity` OR-alternative against
+ * `components.securitySchemes` into placeholder auth values, routed by
+ * location (header/query/cookie) so the caller can feed them into the
+ * matching HAR array. First code in the library to actually resolve a
+ * security requirement against its scheme definition. */
+export declare function resolveAuthPlaceholders(security: Array<Record<string, string[]>>, securitySchemes?: Record<string, OpenAPISecuritySchemeData>): ResolvedAuthPlaceholder[];
+/** Picks the request body media type to sample: prefers `application/json`,
+ * else the first declared content type. Surfaces the author-supplied
+ * `example`/`examples` value (never read anywhere else in the codebase
+ * today) so the caller can prefer it over a schema-faker-generated one. */
+export declare function pickRequestBodyMedia(requestBody?: OpenAPIRequestBodyData): ResolvedRequestBodyMedia | null;
+interface BuildHarRequestInput {
+    method: HttpMethod;
+    path: string;
+    servers?: OpenAPIServerData[];
+    parameters: OpenAPIParameterData[];
+    security: Array<Record<string, string[]>>;
+    securitySchemes?: Record<string, OpenAPISecuritySchemeData>;
+    media: ResolvedRequestBodyMedia | null;
+    resolvedBodyValue: unknown;
+}
+/** Assembles a HAR request object from a resolved operation — the input to
+ * `generateSnippet`/`@readme/httpsnippet`. Query parameters are supplied only
+ * via the `queryString` array (not appended to `url`); HTTPSnippet's own
+ * `prepare()` step reconstructs and encodes the final URL from that array. */
+export declare function buildHarRequest(input: BuildHarRequestInput): CodeSampleHarRequest;
+/** Generates a single target/client code sample for a resolved HAR request
+ * via @readme/httpsnippet. Fails soft: an unsupported target/client pair or a
+ * malformed request resolves to an empty string rather than throwing, so one
+ * bad operation (or a stale dropdown selection) can't crash the panel.
+ * `target`/`client` come from `getAvailableCodeSampleTargets()`'s own keys, so
+ * they're always valid at the httpsnippet level — the cast below only works
+ * around TargetId/ClientId not being exported types we can name directly. */
+export declare function generateSnippet(harRequest: CodeSampleHarRequest, target: string, client: string): string;
+export {};

package/dist/helpers/exampleSchema.d.ts

@@ -0,0 +1,19 @@
+export type JsonSchema = Record<string, unknown>;
+export declare function includesType(schema: JsonSchema, type: string): boolean;
+/**
+ * Prepares a schema for json-schema-faker's `generate()` so the Example tab
+ * shows something plausible and consistent with the Schema tab:
+ *
+ * - Leftover `$ref` nodes (resolveDocument's cycle cut-points) are unrolled
+ *   exactly one level via `deref`, so a recursive schema's example shows one
+ *   real nested occurrence. The second occurrence of the same ref on a path
+ *   is cut to `{ type: "null" }` when the target allows null, else `{}`.
+ *   Without this, generate() would throw on the unresolvable pointer and the
+ *   tab would silently render nothing.
+ * - `oneOf`/`anyOf` collapse to their first branch, matching the case
+ *   SchemaTree shows by default, instead of letting generate() pick an
+ *   unrelated-looking one.
+ * - Plain string fields get placeholder examples (and `*id` fields a uuid
+ *   format) instead of random character noise.
+ */
+export declare function extendExampleSchema(schema: JsonSchema, deref?: (ref: string) => unknown, active?: Set<object>, refStack?: ReadonlySet<string>): JsonSchema;

package/dist/helpers/hljsLanguages.d.ts

@@ -0,0 +1,6 @@
+export declare function hljsLanguageForTarget(target: string): string;
+export declare function isHljsLanguageReady(hljsName: string): boolean;
+/** Registers a highlight.js grammar on first use. No-op if already
+ * registered, if it's "plaintext" (needs no registration), or if there's no
+ * loader for it (CodeBlock falls back to unhighlighted text in that case). */
+export declare function ensureHljsLanguage(hljsName: string): Promise<void>;

package/dist/helpers/openapiParser.d.ts

@@ -0,0 +1,10 @@
+import { OpenAPIDocumentData } from '../types/openapi';
+import { ConfigInterface } from '../config/config';
+export declare function parseDocument(raw: string): Promise<{
+    diagnostics: unknown[];
+    document: OpenAPIDocumentData | null;
+}>;
+export declare function parseAndRender(raw: string, config?: ConfigInterface): Promise<{
+    diagnostics: unknown[];
+    view: import("react").JSX.Element | null;
+}>;

package/dist/helpers/openapiSearchIndex.d.ts

@@ -0,0 +1,3 @@
+import { OpenAPIDocumentData } from '../types/openapi';
+import { SearchEntry } from './searchIndex';
+export declare function buildOpenAPISearchIndex(openapi: OpenAPIDocumentData): SearchEntry[];