redoc 2.0.0-rc.9 → 2.1.0

package/typings/services/SearchStore.d.ts

@@ -1,14 +1,16 @@
-import { IMenuItem } from './MenuStore';
-import { OperationModel } from './models';
+import type { IMenuItem } from './types';
+import type { OperationModel } from './models';
 import Worker from './SearchWorker.worker';
 export declare class SearchStore<T> {
     searchWorker: Worker;
     indexItems(groups: Array<IMenuItem | OperationModel>): void;
     add(title: string, body: string, meta?: T): void;
-    search(q: string): Promise<import("./SearchWorker.worker").SearchResult<T>[]>;
+    dispose(): void;
+    search(q: string): Promise<import("./types").SearchResult<T>[]>;
     toJS(): Promise<{
         store: any[];
         index: object;
     }>;
     load(state: any): void;
+    fromExternalJS(path?: string, exportName?: string): void;
 }

package/typings/services/SearchWorker.worker.d.ts

@@ -1,18 +1,12 @@
+import type { SearchResult } from './types';
 export default class Worker {
     add: typeof add;
     done: typeof done;
     search: typeof search;
     toJS: typeof toJS;
     load: typeof load;
-}
-export interface SearchDocument {
-    title: string;
-    description: string;
-    id: string;
-}
-export interface SearchResult<T = string> {
-    meta: T;
-    score: number;
+    dispose: typeof dispose;
+    fromExternalJS: typeof fromExternalJS;
 }
 export declare function add<T>(title: string, description: string, meta?: T): void;
 export declare function done(): Promise<void>;
@@ -20,5 +14,7 @@ export declare function toJS(): Promise<{
     store: any[];
     index: object;
 }>;
+export declare function fromExternalJS(path: string, exportName: string): Promise<void>;
 export declare function load(state: any): Promise<void>;
+export declare function dispose(): Promise<void>;
 export declare function search<Meta = string>(q: string, limit?: number): Promise<Array<SearchResult<Meta>>>;

package/typings/services/SpecStore.d.ts

@@ -1,11 +1,12 @@
-import { OpenAPIExternalDocumentation, OpenAPISpec } from '../types';
-import { ContentItemModel } from './MenuBuilder';
+import type { OpenAPIExternalDocumentation, OpenAPISpec } from '../types';
 import { ApiInfoModel } from './models/ApiInfo';
+import { WebhookModel } from './models/Webhook';
 import { SecuritySchemesModel } from './models/SecuritySchemes';
 import { OpenAPIParser } from './OpenAPIParser';
-import { RedocNormalizedOptions } from './RedocNormalizedOptions';
+import type { RedocNormalizedOptions } from './RedocNormalizedOptions';
+import type { ContentItemModel } from './types';
 /**
- * Store that containts all the specification related information in the form of tree
+ * Store that contains all the specification related information in the form of tree
  */
 export declare class SpecStore {
     private options;
@@ -14,5 +15,6 @@ export declare class SpecStore {
     externalDocs?: OpenAPIExternalDocumentation;
     contentItems: ContentItemModel[];
     securitySchemes: SecuritySchemesModel;
+    webhooks?: WebhookModel;
     constructor(spec: OpenAPISpec, specUrl: string | undefined, options: RedocNormalizedOptions);
 }

package/typings/services/index.d.ts

@@ -11,3 +11,4 @@ export * from './RedocNormalizedOptions';
 export * from './MenuBuilder';
 export * from './SearchStore';
 export * from './MarkerService';
+export * from './types';

package/typings/services/models/ApiInfo.d.ts

@@ -1,16 +1,19 @@
-import { OpenAPIContact, OpenAPIInfo, OpenAPILicense } from '../../types';
-import { OpenAPIParser } from '../OpenAPIParser';
+import type { OpenAPIContact, OpenAPIInfo, OpenAPILicense } from '../../types';
+import type { OpenAPIParser } from '../OpenAPIParser';
+import { RedocNormalizedOptions } from '../RedocNormalizedOptions';
 export declare class ApiInfoModel implements OpenAPIInfo {
     private parser;
+    private options;
     title: string;
     version: string;
     description: string;
+    summary: string;
     termsOfService?: string;
     contact?: OpenAPIContact;
     license?: OpenAPILicense;
     downloadLink?: string;
     downloadFileName?: string;
-    constructor(parser: OpenAPIParser);
+    constructor(parser: OpenAPIParser, options?: RedocNormalizedOptions);
     private getDownloadLink;
     private getDownloadFileName;
 }

package/typings/services/models/Callback.d.ts

@@ -0,0 +1,11 @@
+import { OperationModel } from './Operation';
+import type { OpenAPIParser } from '../OpenAPIParser';
+import type { OpenAPICallback, Referenced } from '../../types';
+import type { RedocNormalizedOptions } from '../RedocNormalizedOptions';
+export declare class CallbackModel {
+    expanded: boolean;
+    name: string;
+    operations: OperationModel[];
+    constructor(parser: OpenAPIParser, name: string, infoOrRef: Referenced<OpenAPICallback>, pointer: string, options: RedocNormalizedOptions);
+    toggle(): void;
+}

package/typings/services/models/Example.d.ts

@@ -1,5 +1,5 @@
-import { OpenAPIEncoding, OpenAPIExample, Referenced } from '../../types';
-import { OpenAPIParser } from '../OpenAPIParser';
+import type { OpenAPIEncoding, OpenAPIExample, Referenced } from '../../types';
+import type { OpenAPIParser } from '../OpenAPIParser';
 export declare class ExampleModel {
     mime: string;
     value: any;

package/typings/services/models/Field.d.ts

@@ -1,26 +1,32 @@
-import { OpenAPIParameter, OpenAPIParameterLocation, OpenAPIParameterStyle, Referenced } from '../../types';
-import { RedocNormalizedOptions } from '../RedocNormalizedOptions';
-import { OpenAPIParser } from '../OpenAPIParser';
+import type { OpenAPIParameter, OpenAPIParameterLocation, OpenAPIParameterStyle, Referenced } from '../../types';
+import type { RedocNormalizedOptions } from '../RedocNormalizedOptions';
+import type { OpenAPIParser } from '../OpenAPIParser';
 import { SchemaModel } from './Schema';
+import { ExampleModel } from './Example';
 /**
  * Field or Parameter model ready to be used by components
  */
 export declare class FieldModel {
-    expanded: boolean;
+    expanded: boolean | undefined;
     schema: SchemaModel;
     name: string;
     required: boolean;
     description: string;
     example?: string;
+    examples?: Record<string, ExampleModel> | any[];
     deprecated: boolean;
     in?: OpenAPIParameterLocation;
     kind: string;
-    extensions?: Dict<any>;
+    extensions?: Record<string, any>;
     explode: boolean;
     style?: OpenAPIParameterStyle;
+    const?: any;
+    serializationMime?: string;
     constructor(parser: OpenAPIParser, infoOrRef: Referenced<OpenAPIParameter> & {
         name?: string;
         kind?: string;
-    }, pointer: string, options: RedocNormalizedOptions);
+    }, pointer: string, options: RedocNormalizedOptions, refsStack?: string[]);
     toggle(): void;
+    collapse(): void;
+    expand(): void;
 }

package/typings/services/models/Group.model.d.ts

@@ -1,7 +1,5 @@
-import { OpenAPIExternalDocumentation, OpenAPITag } from '../../types';
-import { MarkdownHeading } from '../MarkdownRenderer';
-import { ContentItemModel } from '../MenuBuilder';
-import { IMenuItem, MenuItemGroupType } from '../MenuStore';
+import type { OpenAPIExternalDocumentation, OpenAPITag } from '../../types';
+import type { ContentItemModel, IMenuItem, MarkdownHeading, MenuItemGroupType } from '../types';
 /**
  * Operations Group model ready to be used by components
  */
@@ -9,6 +7,7 @@ export declare class GroupModel implements IMenuItem {
     id: string;
     absoluteIdx?: number;
     name: string;
+    sidebarLabel: string;
     description?: string;
     type: MenuItemGroupType;
     items: ContentItemModel[];

package/typings/services/models/MediaContent.d.ts

@@ -1,25 +1,24 @@
-import { OpenAPIMediaType } from '../../types';
+import type { OpenAPIMediaType } from '../../types';
 import { MediaTypeModel } from './MediaType';
-import { OpenAPIParser } from '../OpenAPIParser';
-import { RedocNormalizedOptions } from '../RedocNormalizedOptions';
+import type { OpenAPIParser } from '../OpenAPIParser';
+import type { RedocNormalizedOptions } from '../RedocNormalizedOptions';
 /**
  * MediaContent model ready to be sued by React components
  * Contains multiple MediaTypes and keeps track of the currently active one
  */
 export declare class MediaContentModel {
-    parser: OpenAPIParser;
     isRequestType: boolean;
     mediaTypes: MediaTypeModel[];
     activeMimeIdx: number;
     /**
      * @param isRequestType needed to know if skipe RO/RW fields in objects
      */
-    constructor(parser: OpenAPIParser, info: Dict<OpenAPIMediaType>, isRequestType: boolean, options: RedocNormalizedOptions);
+    constructor(parser: OpenAPIParser, info: Record<string, OpenAPIMediaType>, isRequestType: boolean, options: RedocNormalizedOptions);
     /**
      * Set active media type by index
      * @param idx media type index
      */
     activate(idx: number): void;
-    readonly active: MediaTypeModel;
-    readonly hasSample: boolean;
+    get active(): MediaTypeModel;
+    get hasSample(): boolean;
 }

package/typings/services/models/MediaType.d.ts

@@ -1,7 +1,7 @@
-import { OpenAPIMediaType } from '../../types';
-import { RedocNormalizedOptions } from '../RedocNormalizedOptions';
+import type { OpenAPIMediaType } from '../../types';
+import type { RedocNormalizedOptions } from '../RedocNormalizedOptions';
 import { SchemaModel } from './Schema';
-import { OpenAPIParser } from '../OpenAPIParser';
+import type { OpenAPIParser } from '../OpenAPIParser';
 import { ExampleModel } from './Example';
 export declare class MediaTypeModel {
     examples?: {
@@ -11,6 +11,7 @@ export declare class MediaTypeModel {
     name: string;
     isRequestType: boolean;
     onlyRequiredInSamples: boolean;
+    generatedPayloadSamplesMaxDepth: number;
     /**
      * @param isRequestType needed to know if skipe RO/RW fields in objects
      */

package/typings/services/models/Operation.d.ts

@@ -1,13 +1,21 @@
-import { IMenuItem } from '../MenuStore';
 import { GroupModel } from './Group.model';
 import { SecurityRequirementModel } from './SecurityRequirement';
-import { OpenAPIExternalDocumentation, OpenAPIServer, OpenAPIXCodeSample } from '../../types';
-import { ContentItemModel, ExtendedOpenAPIOperation } from '../MenuBuilder';
-import { OpenAPIParser } from '../OpenAPIParser';
-import { RedocNormalizedOptions } from '../RedocNormalizedOptions';
+import { CallbackModel } from './Callback';
 import { FieldModel } from './Field';
 import { RequestBodyModel } from './RequestBody';
 import { ResponseModel } from './Response';
+import type { OpenAPIExternalDocumentation, OpenAPIServer, OpenAPIXCodeSample } from '../../types';
+import type { OpenAPIParser } from '../OpenAPIParser';
+import type { RedocNormalizedOptions } from '../RedocNormalizedOptions';
+import type { MediaContentModel } from './MediaContent';
+import type { ContentItemModel, ExtendedOpenAPIOperation, IMenuItem } from '../types';
+export interface XPayloadSample {
+    lang: 'payload';
+    label: string;
+    requestBodyContent: MediaContentModel;
+    source: string;
+}
+export declare function isPayloadSample(sample: XPayloadSample | OpenAPIXCodeSample): sample is XPayloadSample;
 /**
  * Operation model ready to be used by components
  */
@@ -18,6 +26,7 @@ export declare class OperationModel implements IMenuItem {
     id: string;
     absoluteIdx?: number;
     name: string;
+    sidebarLabel: string;
     description?: string;
     type: "operation";
     parent?: GroupModel;
@@ -29,14 +38,17 @@ export declare class OperationModel implements IMenuItem {
     expanded: boolean;
     pointer: string;
     operationId?: string;
+    operationHash?: string;
     httpVerb: string;
     deprecated: boolean;
     path: string;
     servers: OpenAPIServer[];
     security: SecurityRequirementModel[];
-    codeSamples: OpenAPIXCodeSample[];
-    extensions: Dict<any>;
-    constructor(parser: OpenAPIParser, operationSpec: ExtendedOpenAPIOperation, parent: GroupModel | undefined, options: RedocNormalizedOptions);
+    extensions: Record<string, any>;
+    isCallback: boolean;
+    isWebhook: boolean;
+    isEvent: boolean;
+    constructor(parser: OpenAPIParser, operationSpec: ExtendedOpenAPIOperation, parent: GroupModel | undefined, options: RedocNormalizedOptions, isCallback?: boolean);
     /**
      * set operation as active (used by side menu)
      */
@@ -45,9 +57,15 @@ export declare class OperationModel implements IMenuItem {
      * set operation as inactive (used by side menu)
      */
     deactivate(): void;
+    /**
+     * Toggle expansion in middle panel (for callbacks, which are operations)
+     */
+    toggle(): void;
     expand(): void;
     collapse(): void;
-    readonly requestBody: RequestBodyModel | undefined;
-    readonly parameters: FieldModel[];
-    readonly responses: ResponseModel[];
+    get requestBody(): RequestBodyModel | undefined;
+    get codeSamples(): (OpenAPIXCodeSample | XPayloadSample)[];
+    get parameters(): FieldModel[];
+    get responses(): ResponseModel[];
+    get callbacks(): CallbackModel[];
 }

package/typings/services/models/RequestBody.d.ts

@@ -1,10 +1,17 @@
-import { OpenAPIRequestBody, Referenced } from '../../types';
-import { OpenAPIParser } from '../OpenAPIParser';
-import { RedocNormalizedOptions } from '../RedocNormalizedOptions';
+import type { OpenAPIRequestBody, Referenced } from '../../types';
+import type { OpenAPIParser } from '../OpenAPIParser';
+import type { RedocNormalizedOptions } from '../RedocNormalizedOptions';
 import { MediaContentModel } from './MediaContent';
+type RequestBodyProps = {
+    parser: OpenAPIParser;
+    infoOrRef: Referenced<OpenAPIRequestBody>;
+    options: RedocNormalizedOptions;
+    isEvent: boolean;
+};
 export declare class RequestBodyModel {
     description: string;
-    required: boolean;
+    required?: boolean;
     content?: MediaContentModel;
-    constructor(parser: OpenAPIParser, infoOrRef: Referenced<OpenAPIRequestBody>, options: RedocNormalizedOptions);
+    constructor({ parser, infoOrRef, options, isEvent }: RequestBodyProps);
 }
+export {};

package/typings/services/models/Response.d.ts

@@ -1,8 +1,16 @@
-import { OpenAPIResponse, Referenced } from '../../types';
-import { OpenAPIParser } from '../OpenAPIParser';
-import { RedocNormalizedOptions } from '../RedocNormalizedOptions';
+import type { OpenAPIResponse, Referenced } from '../../types';
+import type { OpenAPIParser } from '../OpenAPIParser';
+import type { RedocNormalizedOptions } from '../RedocNormalizedOptions';
 import { FieldModel } from './Field';
 import { MediaContentModel } from './MediaContent';
+type ResponseProps = {
+    parser: OpenAPIParser;
+    code: string;
+    defaultAsError: boolean;
+    infoOrRef: Referenced<OpenAPIResponse>;
+    options: RedocNormalizedOptions;
+    isEvent: boolean;
+};
 export declare class ResponseModel {
     expanded: boolean;
     content?: MediaContentModel;
@@ -11,6 +19,8 @@ export declare class ResponseModel {
     description: string;
     type: string;
     headers: FieldModel[];
-    constructor(parser: OpenAPIParser, code: string, defaultAsError: boolean, infoOrRef: Referenced<OpenAPIResponse>, options: RedocNormalizedOptions);
+    extensions: Record<string, any>;
+    constructor({ parser, code, defaultAsError, infoOrRef, options, isEvent: isRequest, }: ResponseProps);
     toggle(): void;
 }
+export {};

package/typings/services/models/Schema.d.ts

@@ -1,12 +1,13 @@
-import { OpenAPIExternalDocumentation, OpenAPISchema, Referenced } from '../../types';
-import { OpenAPIParser } from '../OpenAPIParser';
-import { RedocNormalizedOptions } from '../RedocNormalizedOptions';
+import type { OpenAPIExternalDocumentation, OpenAPISchema, Referenced } from '../../types';
+import type { OpenAPIParser } from '../OpenAPIParser';
+import type { RedocNormalizedOptions } from '../RedocNormalizedOptions';
 import { FieldModel } from './Field';
-import { MergedOpenAPISchema } from '../';
+import { MergedOpenAPISchema } from '../types';
 export declare class SchemaModel {
     private options;
+    private refsStack;
     pointer: string;
-    type: string;
+    type: string | string[];
     displayType: string;
     typePrefix: string;
     title: string;
@@ -20,6 +21,7 @@ export declare class SchemaModel {
     deprecated: boolean;
     pattern?: string;
     example?: any;
+    examples?: any[];
     enum: any[];
     default?: any;
     readOnly: boolean;
@@ -33,18 +35,25 @@ export declare class SchemaModel {
     activeOneOf: number;
     rawSchema: OpenAPISchema;
     schema: MergedOpenAPISchema;
-    extensions?: Dict<any>;
+    extensions?: Record<string, any>;
+    const: any;
+    contentEncoding?: string;
+    contentMediaType?: string;
+    minItems?: number;
+    maxItems?: number;
     /**
      * @param isChild if schema discriminator Child
      * When true forces dereferencing in allOfs even if circular
      */
-    constructor(parser: OpenAPIParser, schemaOrRef: Referenced<OpenAPISchema>, pointer: string, options: RedocNormalizedOptions, isChild?: boolean);
+    constructor(parser: OpenAPIParser, schemaOrRef: Referenced<OpenAPISchema>, pointer: string, options: RedocNormalizedOptions, isChild?: boolean, refsStack?: string[]);
     /**
      * Set specified alternative schema as active
      * @param idx oneOf index
      */
     activateOneOf(idx: number): void;
+    hasType(type: string): boolean;
     init(parser: OpenAPIParser, isChild: boolean): void;
     private initOneOf;
     private initDiscriminator;
+    private initConditionalOperators;
 }

package/typings/services/models/SecurityRequirement.d.ts

@@ -1,8 +1,9 @@
-import { OpenAPISecurityRequirement, OpenAPISecurityScheme } from '../../types';
-import { OpenAPIParser } from '../OpenAPIParser';
+import type { OpenAPISecurityRequirement, OpenAPISecurityScheme } from '../../types';
+import type { OpenAPIParser } from '../OpenAPIParser';
 export interface SecurityScheme extends OpenAPISecurityScheme {
     id: string;
     sectionId: string;
+    displayName: string;
     scopes: string[];
 }
 export declare class SecurityRequirementModel {

package/typings/services/models/SecuritySchemes.d.ts

@@ -1,10 +1,11 @@
-import { OpenAPISecurityScheme, Referenced } from '../../types';
-import { OpenAPIParser } from '../OpenAPIParser';
+import type { OpenAPISecurityScheme, Referenced } from '../../types';
+import type { OpenAPIParser } from '../OpenAPIParser';
 export declare class SecuritySchemeModel {
     id: string;
     sectionId: string;
     type: OpenAPISecurityScheme['type'];
     description: string;
+    displayName: string;
     apiKey?: {
         name: string;
         in: OpenAPISecurityScheme['in'];

package/typings/services/models/Webhook.d.ts

@@ -0,0 +1,9 @@
+import type { OpenAPIPath, Referenced } from '../../types';
+import type { OpenAPIParser } from '../OpenAPIParser';
+import { OperationModel } from './Operation';
+import type { RedocNormalizedOptions } from '../RedocNormalizedOptions';
+export declare class WebhookModel {
+    operations: OperationModel[];
+    constructor(parser: OpenAPIParser, options: RedocNormalizedOptions, infoOrRef?: Referenced<OpenAPIPath>);
+    initWebhooks(parser: OpenAPIParser, webhooks: OpenAPIPath, options: RedocNormalizedOptions): void;
+}

package/typings/services/models/index.d.ts

@@ -10,3 +10,4 @@ export * from './Schema';
 export * from './Field';
 export * from './ApiInfo';
 export * from './SecuritySchemes';
+export * from './Callback';

package/typings/services/types.d.ts

@@ -0,0 +1,107 @@
+/// <reference types="react" />
+import { OpenAPIOperation, OpenAPIParameter, OpenAPISchema, OpenAPIServer, OpenAPITag, Referenced } from '../types';
+import { AppStore } from './AppStore';
+import { GroupModel } from './models';
+import { OperationModel } from './models/Operation';
+import { RedocRawOptions } from './RedocNormalizedOptions';
+export interface StoreState {
+    menu: {
+        activeItemIdx: number;
+    };
+    spec: {
+        url?: string;
+        data: any;
+    };
+    searchIndex: any;
+    options: RedocRawOptions;
+}
+export interface LabelsConfig {
+    enum: string;
+    enumSingleValue: string;
+    enumArray: string;
+    default: string;
+    deprecated: string;
+    example: string;
+    examples: string;
+    recursive: string;
+    arrayOf: string;
+    webhook: string;
+    const: string;
+    noResultsFound: string;
+    download: string;
+    downloadSpecification: string;
+    responses: string;
+    callbackResponses: string;
+    requestSamples: string;
+    responseSamples: string;
+}
+export type LabelsConfigRaw = Partial<LabelsConfig>;
+export interface MDXComponentMeta {
+    component: React.ComponentType;
+    propsSelector: (store?: AppStore) => any;
+    props?: object;
+}
+export interface MarkdownHeading {
+    id: string;
+    name: string;
+    level: number;
+    items?: MarkdownHeading[];
+    description?: string;
+}
+export type ContentItemModel = GroupModel | OperationModel;
+export type TagInfo = OpenAPITag & {
+    operations: ExtendedOpenAPIOperation[];
+    used?: boolean;
+};
+export type ExtendedOpenAPIOperation = {
+    pointer: string;
+    pathName: string;
+    httpVerb: string;
+    pathParameters: Array<Referenced<OpenAPIParameter>>;
+    pathServers: Array<OpenAPIServer> | undefined;
+    isWebhook: boolean;
+} & OpenAPIOperation;
+export type TagsInfoMap = Record<string, TagInfo>;
+export interface TagGroup {
+    name: string;
+    tags: string[];
+}
+export type MenuItemGroupType = 'group' | 'tag' | 'section' | 'schema';
+export type MenuItemType = MenuItemGroupType | 'operation';
+export interface IMenuItem {
+    id: string;
+    absoluteIdx?: number;
+    name: string;
+    sidebarLabel: string;
+    description?: string;
+    depth: number;
+    active: boolean;
+    expanded: boolean;
+    items: IMenuItem[];
+    parent?: IMenuItem;
+    deprecated?: boolean;
+    type: MenuItemType;
+    deactivate(): void;
+    activate(): void;
+    collapse(): void;
+    expand(): void;
+}
+export interface SearchDocument {
+    title: string;
+    description: string;
+    id: string;
+}
+export interface SearchResult<T = string> {
+    meta: T;
+    score: number;
+}
+export declare enum SideNavStyleEnum {
+    SummaryOnly = "summary-only",
+    PathOnly = "path-only",
+    IdOnly = "id-only"
+}
+export type MergedOpenAPISchema = OpenAPISchema & {
+    'x-refsStack'?: string[];
+    'x-parentRefs'?: string[];
+    'x-circular-ref'?: boolean;
+};

package/typings/styled-components.d.ts

@@ -1,14 +1,11 @@
 import * as styledComponents from 'styled-components';
-import { ResolvedThemeInterface } from './theme';
-export { ResolvedThemeInterface };
-declare const styled: styledComponents.ThemedBaseStyledInterface<ResolvedThemeInterface>, css: styledComponents.BaseThemedCssFunction<ResolvedThemeInterface>, createGlobalStyle: <P extends object = {}>(first: TemplateStringsArray | styledComponents.CSSObject | styledComponents.InterpolationFunction<styledComponents.ThemedStyledProps<P, ResolvedThemeInterface>>, ...interpolations: styledComponents.Interpolation<styledComponents.ThemedStyledProps<P, ResolvedThemeInterface>>[]) => styledComponents.GlobalStyleComponent<P, ResolvedThemeInterface>, keyframes: {
-    (strings: TemplateStringsArray | styledComponents.CSSKeyframes, ...interpolations: styledComponents.SimpleInterpolation[]): styledComponents.Keyframes;
-    (strings: string[] | TemplateStringsArray, ...interpolations: styledComponents.SimpleInterpolation[]): styledComponents.Keyframes;
-}, ThemeProvider: import("react").ComponentClass<styledComponents.ThemeProviderProps<ResolvedThemeInterface, ResolvedThemeInterface>, any>;
+import type { ResolvedThemeInterface } from './theme';
+export type { ResolvedThemeInterface };
+declare const styled: styledComponents.ThemedStyledInterface<ResolvedThemeInterface>, css: styledComponents.ThemedCssFunction<ResolvedThemeInterface>, createGlobalStyle: <P extends object = {}>(first: TemplateStringsArray | styledComponents.CSSObject | styledComponents.InterpolationFunction<styledComponents.ThemedStyledProps<P, ResolvedThemeInterface>>, ...interpolations: styledComponents.Interpolation<styledComponents.ThemedStyledProps<P, ResolvedThemeInterface>>[]) => styledComponents.GlobalStyleComponent<P, ResolvedThemeInterface>, keyframes: (strings: TemplateStringsArray | styledComponents.CSSKeyframes, ...interpolations: styledComponents.SimpleInterpolation[]) => styledComponents.Keyframes, ThemeProvider: styledComponents.BaseThemeProviderComponent<ResolvedThemeInterface, ResolvedThemeInterface>;
 export declare const media: {
-    lessThan(breakpoint: any, print?: boolean | undefined): (...args: any[]) => styledComponents.FlattenInterpolation<styledComponents.ThemeProps<ResolvedThemeInterface>>;
-    greaterThan(breakpoint: any): (...args: any[]) => styledComponents.FlattenInterpolation<styledComponents.ThemeProps<ResolvedThemeInterface>>;
-    between(firstBreakpoint: any, secondBreakpoint: any): (...args: any[]) => styledComponents.FlattenInterpolation<styledComponents.ThemeProps<ResolvedThemeInterface>>;
+    lessThan(breakpoint: any, print?: boolean, extra?: string): (...args: any[]) => styledComponents.FlattenInterpolation<styledComponents.ThemedStyledProps<object, ResolvedThemeInterface>>;
+    greaterThan(breakpoint: any): (...args: any[]) => styledComponents.FlattenInterpolation<styledComponents.ThemedStyledProps<object, ResolvedThemeInterface>>;
+    between(firstBreakpoint: any, secondBreakpoint: any): (...args: any[]) => styledComponents.FlattenInterpolation<styledComponents.ThemedStyledProps<object, ResolvedThemeInterface>>;
 };
 export { css, createGlobalStyle, keyframes, ThemeProvider };
 export default styled;

package/typings/styled-patch.d.ts

@@ -2,16 +2,6 @@ import * as styledComponents from 'styled-components';
 
 // FIXME
 declare module 'styled-components' {
-  export interface ThemedStyledFunction<
-    C extends keyof JSX.IntrinsicElements | React.ComponentType<any>,
-    T extends object,
-    O extends object = {},
-    A extends keyof any = never
-  > extends ThemedStyledFunctionBase<C, T, O, A> {
-    withConfig(config: any): any;
-    // tslint:enable:unified-signatures
-  }
-
   interface ThemedStyledComponentsModule<T> {
     keyframes(
       strings: TemplateStringsArray | string[],