redoc 2.0.0-rc.9 → 2.1.0

package/typings/types/open-api.ts

@@ -0,0 +1,297 @@
+import type { Omit } from './index';
+
+export interface OpenAPISpec {
+  openapi: string;
+  info: OpenAPIInfo;
+  servers?: OpenAPIServer[];
+  paths: OpenAPIPaths;
+  components?: OpenAPIComponents;
+  security?: OpenAPISecurityRequirement[];
+  tags?: OpenAPITag[];
+  externalDocs?: OpenAPIExternalDocumentation;
+  'x-webhooks'?: OpenAPIPaths;
+  webhooks?: OpenAPIPaths;
+}
+
+export interface OpenAPIInfo {
+  title: string;
+  version: string;
+
+  description?: string;
+  summary?: string;
+  termsOfService?: string;
+  contact?: OpenAPIContact;
+  license?: OpenAPILicense;
+}
+
+export interface OpenAPIServer {
+  url: string;
+  description?: string;
+  variables?: { [name: string]: OpenAPIServerVariable };
+}
+
+export interface OpenAPIServerVariable {
+  enum?: string[];
+  default: string;
+  description?: string;
+}
+
+export interface OpenAPIPaths {
+  [path: string]: OpenAPIPath;
+}
+export interface OpenAPIRef {
+  'x-refsStack'?: string[];
+  $ref: string;
+  summary?: string;
+  description?: string;
+}
+
+export type Referenced<T> = OpenAPIRef | T;
+
+export interface OpenAPIPath {
+  summary?: string;
+  description?: string;
+  get?: OpenAPIOperation;
+  put?: OpenAPIOperation;
+  post?: OpenAPIOperation;
+  delete?: OpenAPIOperation;
+  options?: OpenAPIOperation;
+  head?: OpenAPIOperation;
+  patch?: OpenAPIOperation;
+  trace?: OpenAPIOperation;
+  servers?: OpenAPIServer[];
+  parameters?: Array<Referenced<OpenAPIParameter>>;
+  $ref?: string;
+}
+
+export interface OpenAPIXCodeSample {
+  lang: string;
+  label?: string;
+  source: string;
+}
+
+export interface OpenAPIOperation {
+  tags?: string[];
+  summary?: string;
+  description?: string;
+  externalDocs?: OpenAPIExternalDocumentation;
+  operationId?: string;
+  parameters?: Array<Referenced<OpenAPIParameter>>;
+  requestBody?: Referenced<OpenAPIRequestBody>;
+  responses: OpenAPIResponses;
+  callbacks?: { [name: string]: Referenced<OpenAPICallback> };
+  deprecated?: boolean;
+  security?: OpenAPISecurityRequirement[];
+  servers?: OpenAPIServer[];
+  'x-codeSamples'?: OpenAPIXCodeSample[];
+  'x-code-samples'?: OpenAPIXCodeSample[]; // deprecated
+}
+
+export interface OpenAPIParameter {
+  name: string;
+  in?: OpenAPIParameterLocation;
+  description?: string;
+  required?: boolean;
+  deprecated?: boolean;
+  allowEmptyValue?: boolean;
+  style?: OpenAPIParameterStyle;
+  explode?: boolean;
+  allowReserved?: boolean;
+  schema?: Referenced<OpenAPISchema>;
+  example?: any;
+  examples?: { [media: string]: Referenced<OpenAPIExample> };
+  content?: { [media: string]: OpenAPIMediaType };
+  encoding?: Record<string, OpenAPIEncoding>;
+  const?: any;
+}
+
+export interface OpenAPIExample {
+  value: any;
+  summary?: string;
+  description?: string;
+  externalValue?: string;
+}
+
+export interface OpenAPISchema {
+  $ref?: string;
+  type?: string | string[];
+  properties?: { [name: string]: OpenAPISchema };
+  patternProperties?: { [name: string]: OpenAPISchema };
+  additionalProperties?: boolean | OpenAPISchema;
+  unevaluatedProperties?: boolean | OpenAPISchema;
+  description?: string;
+  default?: any;
+  items?: OpenAPISchema | OpenAPISchema[] | boolean;
+  required?: string[];
+  readOnly?: boolean;
+  writeOnly?: boolean;
+  deprecated?: boolean;
+  format?: string;
+  externalDocs?: OpenAPIExternalDocumentation;
+  discriminator?: OpenAPIDiscriminator;
+  nullable?: boolean;
+  oneOf?: OpenAPISchema[];
+  anyOf?: OpenAPISchema[];
+  allOf?: OpenAPISchema[];
+  not?: OpenAPISchema;
+
+  title?: string;
+  multipleOf?: number;
+  maximum?: number;
+  exclusiveMaximum?: boolean | number;
+  minimum?: number;
+  exclusiveMinimum?: boolean | number;
+  maxLength?: number;
+  minLength?: number;
+  pattern?: string;
+  maxItems?: number;
+  minItems?: number;
+  uniqueItems?: boolean;
+  maxProperties?: number;
+  minProperties?: number;
+  enum?: any[];
+  example?: any;
+
+  if?: OpenAPISchema;
+  else?: OpenAPISchema;
+  then?: OpenAPISchema;
+  examples?: any[];
+  const?: string;
+  contentEncoding?: string;
+  contentMediaType?: string;
+  prefixItems?: OpenAPISchema[];
+  additionalItems?: OpenAPISchema | boolean;
+}
+
+export interface OpenAPIDiscriminator {
+  propertyName: string;
+  mapping?: { [name: string]: string };
+  'x-explicitMappingOnly'?: boolean;
+}
+
+export interface OpenAPIMediaType {
+  schema?: Referenced<OpenAPISchema>;
+  example?: any;
+  examples?: { [name: string]: Referenced<OpenAPIExample> };
+  encoding?: { [field: string]: OpenAPIEncoding };
+}
+
+export interface OpenAPIEncoding {
+  contentType: string;
+  headers?: { [name: string]: Referenced<OpenAPIHeader> };
+  style: OpenAPIParameterStyle;
+  explode: boolean;
+  allowReserved: boolean;
+}
+
+export type OpenAPIParameterLocation = 'query' | 'header' | 'path' | 'cookie';
+export type OpenAPIParameterStyle =
+  | 'matrix'
+  | 'label'
+  | 'form'
+  | 'simple'
+  | 'spaceDelimited'
+  | 'pipeDelimited'
+  | 'deepObject';
+
+export interface OpenAPIRequestBody {
+  description?: string;
+  required?: boolean;
+  content: { [mime: string]: OpenAPIMediaType };
+
+  'x-examples'?: { [mime: string]: { [name: string]: Referenced<OpenAPIExample> } };
+  'x-example'?: { [mime: string]: any };
+}
+
+export interface OpenAPIResponses {
+  [code: string]: Referenced<OpenAPIResponse>;
+}
+
+export interface OpenAPIResponse
+  extends Pick<OpenAPIRequestBody, 'description' | 'x-examples' | 'x-example'> {
+  headers?: { [name: string]: Referenced<OpenAPIHeader> };
+  links?: { [name: string]: Referenced<OpenAPILink> };
+  content?: { [mime: string]: OpenAPIMediaType };
+}
+
+export interface OpenAPILink {
+  $ref?: string;
+}
+
+export type OpenAPIHeader = Omit<OpenAPIParameter, 'in' | 'name'>;
+
+export interface OpenAPICallback {
+  [name: string]: OpenAPIPath;
+}
+
+export interface OpenAPIComponents {
+  schemas?: { [name: string]: Referenced<OpenAPISchema> };
+  responses?: { [name: string]: Referenced<OpenAPIResponse> };
+  parameters?: { [name: string]: Referenced<OpenAPIParameter> };
+  examples?: { [name: string]: Referenced<OpenAPIExample> };
+  requestBodies?: { [name: string]: Referenced<OpenAPIRequestBody> };
+  headers?: { [name: string]: Referenced<OpenAPIHeader> };
+  securitySchemes?: { [name: string]: Referenced<OpenAPISecurityScheme> };
+  links?: { [name: string]: Referenced<OpenAPILink> };
+  callbacks?: { [name: string]: Referenced<OpenAPICallback> };
+}
+
+export interface OpenAPISecurityRequirement {
+  [name: string]: string[];
+}
+
+export interface OpenAPISecurityScheme {
+  type: 'apiKey' | 'http' | 'oauth2' | 'openIdConnect';
+  description?: string;
+  name?: string;
+  in?: 'query' | 'header' | 'cookie';
+  scheme?: string;
+  bearerFormat: string;
+  flows: {
+    implicit?: {
+      refreshUrl?: string;
+      scopes: Record<string, string>;
+      authorizationUrl: string;
+    };
+    password?: {
+      refreshUrl?: string;
+      scopes: Record<string, string>;
+      tokenUrl: string;
+    };
+    clientCredentials?: {
+      refreshUrl?: string;
+      scopes: Record<string, string>;
+      tokenUrl: string;
+    };
+    authorizationCode?: {
+      refreshUrl?: string;
+      scopes: Record<string, string>;
+      tokenUrl: string;
+    };
+  };
+  openIdConnectUrl?: string;
+}
+
+export interface OpenAPITag {
+  name: string;
+  description?: string;
+  externalDocs?: OpenAPIExternalDocumentation;
+  'x-displayName'?: string;
+}
+
+export interface OpenAPIExternalDocumentation {
+  description?: string;
+  url: string;
+}
+
+export interface OpenAPIContact {
+  name?: string;
+  url?: string;
+  email?: string;
+}
+
+export interface OpenAPILicense {
+  name: string;
+  url?: string;
+  identifier?: string;
+}

package/typings/utils/dom.d.ts

@@ -6,3 +6,4 @@ export declare function querySelector(selector: string): Element | null;
  * un-encoded `<` or `>` characters very well, so don't feed it malformed HTML
  */
 export declare function html2Str(html: string): string;
+export declare function scrollIntoViewIfNeeded(el: HTMLElement, centerIfNeeded?: boolean): void;

package/typings/utils/helpers.d.ts

@@ -1,5 +1,5 @@
 /**
- * Maps over array passing `isLast` bool to iterator as the second arguemnt
+ * Maps over array passing `isLast` bool to iterator as the second argument
  */
 export declare function mapWithLast<T, P>(array: T[], iteratee: (item: T, isLast: boolean) => P): P[];
 /**
@@ -10,7 +10,7 @@ export declare function mapWithLast<T, P>(array: T[], iteratee: (item: T, isLast
  * @param object the object to iterate over
  * @param iteratee the function invoked per iteration.
  */
-export declare function mapValues<T, P>(object: Dict<T>, iteratee: (val: T, key: string, obj: Dict<T>) => P): Dict<P>;
+export declare function mapValues<T, P>(object: Record<string, T>, iteratee: (val: T, key: string, obj: Record<string, T>) => P): Record<string, P>;
 /**
  * flattens collection using `prop` field as a children
  * @param collectionItems collection items
@@ -20,10 +20,11 @@ export declare function flattenByProp<T extends object, P extends keyof T>(colle
 export declare function stripTrailingSlash(path: string): string;
 export declare function isNumeric(n: any): n is number;
 export declare function appendToMdHeading(md: string, heading: string, content: string): string;
-export declare const mergeObjects: <T extends object = object>(target: T, ...sources: T[]) => T;
+export declare const mergeObjects: (target: any, ...sources: any[]) => any;
+export declare const isObject: (item: unknown) => item is Record<string, unknown>;
 /**
  * slugify() returns empty string when failed to slugify.
- * so try to return minimun slugified-string with failed one which keeps original value
+ * so try to return minimum slugified-string with failed one which keeps original value
  * the regex codes are referenced with https://gist.github.com/mathewbyrne/1280286
  */
 export declare function safeSlugify(value: string): string;
@@ -35,4 +36,8 @@ export declare function isAbsoluteUrl(url: string): boolean;
 export declare function resolveUrl(url: string, to: string): string;
 export declare function getBasePath(serverUrl: string): string;
 export declare function titleize(text: string): string;
-export declare function removeQueryString(serverUrl: string): string;
+export declare function removeQueryStringAndHash(serverUrl: string): string;
+export declare function escapeHTMLAttrChars(str: string): string;
+export declare function unescapeHTMLChars(str: string): string;
+export declare function isArray(value: unknown): value is any[];
+export declare function isBoolean(value: unknown): value is boolean;

package/typings/utils/highlight.d.ts

@@ -5,6 +5,7 @@ import 'prismjs/components/prism-coffeescript.js';
 import 'prismjs/components/prism-cpp.js';
 import 'prismjs/components/prism-csharp.js';
 import 'prismjs/components/prism-go.js';
+import 'prismjs/components/prism-http.js';
 import 'prismjs/components/prism-java.js';
 import 'prismjs/components/prism-lua.js';
 import 'prismjs/components/prism-markup-templating.js';
@@ -13,10 +14,13 @@ import 'prismjs/components/prism-objectivec.js';
 import 'prismjs/components/prism-perl.js';
 import 'prismjs/components/prism-php.js';
 import 'prismjs/components/prism-python.js';
+import 'prismjs/components/prism-q.js';
 import 'prismjs/components/prism-ruby.js';
 import 'prismjs/components/prism-scala.js';
 import 'prismjs/components/prism-sql.js';
 import 'prismjs/components/prism-swift.js';
+import 'prismjs/components/prism-yaml.js';
+import 'prismjs/components/prism-csv.js';
 /**
  * map language names to Prism.js names
  */
@@ -25,6 +29,6 @@ export declare function mapLang(lang: string): string;
  * Highlight source code string using Prism.js
  * @param source source code to highlight
  * @param lang highlight language
- * @return highlighted souce code as **html string**
+ * @return highlighted source code as **html string**
  */
-export declare function highlight(source: string, lang?: string): string;
+export declare function highlight(source: string | number | boolean, lang?: string): string;

package/typings/utils/index.d.ts

@@ -7,3 +7,4 @@ export * from './dom';
 export * from './decorators';
 export * from './debug';
 export * from './memoize';
+export * from './sort';

package/typings/utils/jsonToHtml.d.ts

@@ -1 +1 @@
-export declare function jsonToHTML(json: any): string;
+export declare function jsonToHTML(json: any, maxExpandLevel: any): string;

package/typings/utils/openapi.d.ts

@@ -1,34 +1,43 @@
+import { ExtendedOpenAPIOperation } from '../services';
+import { FieldModel } from '../services/models';
 import { OpenAPIParser } from '../services/OpenAPIParser';
-import { OpenAPIEncoding, OpenAPIMediaType, OpenAPIOperation, OpenAPIParameter, OpenAPISchema, OpenAPIServer, Referenced } from '../types';
+import { OpenAPIEncoding, OpenAPIMediaType, OpenAPIParameter, OpenAPIRequestBody, OpenAPIResponse, OpenAPISchema, OpenAPIServer, Referenced } from '../types';
 export declare function isStatusCode(statusCode: string): boolean;
 export declare function getStatusCodeType(statusCode: string | number, defaultAsError?: boolean): string;
 export declare function isOperationName(key: string): boolean;
-export declare function getOperationSummary(operation: OpenAPIOperation): string;
+export declare function getOperationSummary(operation: ExtendedOpenAPIOperation): string;
 export declare function detectType(schema: OpenAPISchema): string;
-export declare function isPrimitiveType(schema: OpenAPISchema, type?: string | undefined): boolean;
+export declare function isPrimitiveType(schema: OpenAPISchema, type?: string | string[] | undefined): any;
 export declare function isJsonLike(contentType: string): boolean;
 export declare function isFormUrlEncoded(contentType: string): boolean;
 export declare function urlFormEncodePayload(payload: object, encoding?: {
     [field: string]: OpenAPIEncoding;
 }): string;
-export declare function serializeParameterValue(parameter: OpenAPIParameter, value: any): string;
+export declare function serializeParameterValueWithMime(value: any, mime: string): string;
+export declare function serializeParameterValue(parameter: (OpenAPIParameter & {
+    serializationMime?: string;
+}) | FieldModel, value: any): string;
+export declare function getSerializedValue(field: FieldModel, example: any): any;
 export declare function langFromMime(contentType: string): string;
 export declare function isNamedDefinition(pointer?: string): boolean;
+export declare function getDefinitionName(pointer?: string): string | undefined;
+export declare function humanizeNumberRange(schema: OpenAPISchema): string | undefined;
 export declare function humanizeConstraints(schema: OpenAPISchema): string[];
-export declare function sortByRequired(fields: Array<{
-    required: boolean;
-    name: string;
-}>, order?: string[]): void;
-export declare function sortByField<T extends string>(fields: Array<{
-    [P in T]: string;
-}>, param: T): void;
+export declare function sortByRequired(fields: FieldModel[], order?: string[]): FieldModel[];
+export declare function sortByField(fields: FieldModel[], param: keyof Pick<FieldModel, 'name' | 'description' | 'kind'>): FieldModel[];
 export declare function mergeParams(parser: OpenAPIParser, pathParams?: Array<Referenced<OpenAPIParameter>>, operationParams?: Array<Referenced<OpenAPIParameter>>): Array<Referenced<OpenAPIParameter>>;
-export declare function mergeSimilarMediaTypes(types: Dict<OpenAPIMediaType>): Dict<OpenAPIMediaType>;
+export declare function mergeSimilarMediaTypes(types: Record<string, OpenAPIMediaType>): Record<string, OpenAPIMediaType>;
+export declare function expandDefaultServerVariables(url: string, variables?: object): string;
 export declare function normalizeServers(specUrl: string | undefined, servers: OpenAPIServer[]): OpenAPIServer[];
-export declare const SECURITY_DEFINITIONS_COMPONENT_NAME = "security-definitions";
+export declare const SECURITY_DEFINITIONS_JSX_NAME = "SecurityDefinitions";
+export declare const OLD_SECURITY_DEFINITIONS_JSX_NAME = "security-definitions";
+export declare const SCHEMA_DEFINITION_JSX_NAME = "SchemaDefinition";
 export declare let SECURITY_SCHEMES_SECTION_PREFIX: string;
 export declare function setSecuritySchemePrefix(prefix: string): void;
 export declare const shortenHTTPVerb: (verb: any) => any;
 export declare function isRedocExtension(key: string): boolean;
-export declare function extractExtensions(obj: object, showExtensions: string[] | true): Dict<any>;
+export declare function extractExtensions(obj: object, showExtensions: string[] | true): Record<string, any>;
 export declare function pluralizeType(displayType: string): string;
+export declare function getContentWithLegacyExamples(info: OpenAPIRequestBody | OpenAPIResponse): {
+    [mime: string]: OpenAPIMediaType;
+} | undefined;

package/typings/utils/sort.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Function that returns a comparator for sorting objects by some specific key alphabetically.
+ *
+ * @param {String} property key of the object to sort, if starts from `-` - reverse
+ */
+export declare function alphabeticallyByProp<T>(property: string): (a: T, b: T) => number;