@redocly/replay 0.13.0-next.7 → 0.14.0-next.0

package/dist/replay.d.ts

@@ -1,9 +1,13 @@
-import { FileResponse } from '@tauri-apps/plugin-dialog';
 import { ImmutableObject } from '@redocly/hookstate-core';
 import { JSX } from 'react/jsx-runtime';
 import { NamedExoticComponent } from 'react';
 import { ReactElement } from 'react';
 
+declare type ApiPath = {
+    path: string;
+    method: string;
+};
+
 declare type AuthorizationCodeOAuthFlowsObject = {
     authorizationUrl: string;
     tokenUrl: string;
@@ -19,7 +23,7 @@ declare type Certificate = {
 };
 
 declare type ChangedOperation = {
-    sourcePath: SourcePath;
+    apiPath: ApiPath;
     requestValues: {
         cookie?: {
             [key: string]: string;
@@ -45,11 +49,13 @@ declare type ClientCredentialsOAuthFlowsObject = {
     scopes: Record<string, string>;
 };
 
-declare type ConvertOperationFunction = (path: string, method: string, openAPI: any) => OpenAPIOperation | undefined;
+declare type ConvertOperationFunction = (path: string, method: string, openAPI: any) => OpenAPIOperation_2 | undefined;
 
 export declare function EmbeddedReplay(props: ReplayAppProps): JSX.Element;
 
-declare type GetOperationURLFunction = (operationId?: string, source?: Source) => string | undefined;
+declare function getAbsoluteProjectDir(projectSlug: string): Promise<string>;
+
+declare type GetOperationURLFunction = (operationId?: string) => string | undefined;
 
 declare type ImplicitOAuthFlowsObject = {
     authorizationUrl?: string;
@@ -60,7 +66,6 @@ declare type InputSettings = {
     corsProxyUrl?: string;
     mockServer?: MockServer;
     disableCollectionsTab?: boolean;
-    disableWorkflowTab?: boolean;
     disableDraft?: boolean;
     oAuth2RedirectURI?: string | null;
     inline?: boolean;
@@ -118,9 +123,151 @@ declare type OAuthFlowsObject = {
     authorizationCode?: AuthorizationCodeOAuthFlowsObject;
 };
 
-declare type OpenAPIOperation = {
+declare interface OpenAPICallback {
+    [name: string]: OpenAPIPath;
+}
+
+declare 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>;
+    };
+}
+
+declare interface OpenAPIContact {
+    name?: string;
+    url?: string;
+    email?: string;
+}
+
+declare interface OpenAPIDefinition {
+    openapi: string;
+    info: OpenAPIInfo;
+    servers?: OpenAPIServer[];
+    paths: OpenAPIPaths;
+    components?: OpenAPIComponents;
+    security?: OpenAPISecurityRequirement[];
+    tags?: OpenAPITag[];
+    externalDocs?: OpenAPIExternalDocumentation;
+    webhooks?: OpenAPIPaths;
+    'x-webhooks'?: OpenAPIPaths;
+    'x-tagGroups'?: Array<{
+        name: string;
+        tags: Array<string>;
+    }>;
+    'x-feedback'?: any;
+}
+
+declare interface OpenAPIDiscriminator {
+    propertyName: string;
+    mapping?: {
+        [name: string]: string;
+    };
+    'x-explicitMappingOnly'?: boolean;
+}
+
+declare interface OpenAPIEncoding {
+    contentType: string;
+    headers?: {
+        [name: string]: Referenced<OpenAPIHeader>;
+    };
+    style: OpenAPIParameterStyle;
+    explode: boolean;
+    allowReserved: boolean;
+}
+
+declare interface OpenAPIExample extends ParsedDescriptionWithSummary {
+    value: any;
+    summary?: string;
+    description?: string;
+    externalValue?: string;
+}
+
+declare interface OpenAPIExternalDocumentation extends ParsedDescription {
+    description?: string;
+    url: string;
+}
+
+declare type OpenAPIHeader = Omit<OpenAPIParameter, 'in' | 'name'>;
+
+declare interface OpenAPIInfo extends ParsedDescriptionWithSummary {
+    title: string;
+    version: string;
+    description?: string;
+    summary?: string;
+    termsOfService?: string;
+    contact?: OpenAPIContact;
+    license?: OpenAPILicense;
+    'x-logo'?: XLogo;
+    'x-metadata'?: XMetadata;
+    'x-seo'?: XSEO;
+}
+
+declare interface OpenAPILicense {
+    name: string;
+    url?: string;
+    identifier?: string;
+}
+
+declare interface OpenAPILink {
+    $ref?: string;
+}
+
+declare interface OpenAPIMediaType {
+    schema?: Referenced<OpenAPISchema>;
+    example?: any;
+    examples?: {
+        [name: string]: Referenced<OpenAPIExample>;
+    };
+    encoding?: {
+        [field: string]: OpenAPIEncoding;
+    };
+}
+
+declare interface OpenAPIOperation extends ParsedDescriptionWithSummary {
+    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-badges'?: OpenAPIXBadges[];
+    'x-hideReplay'?: boolean;
+}
+
+declare type OpenAPIOperation_2 = {
     id: string;
-    sourceId?: string;
     name: string;
     method: string;
     path: string;
@@ -137,11 +284,231 @@ declare type OpenAPIOperation = {
     response?: Response_2 | null;
 };
 
+declare interface OpenAPIParameter extends ParsedDescription {
+    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;
+}
+
+declare type OpenAPIParameterLocation = 'query' | 'header' | 'path' | 'cookie';
+
+declare type OpenAPIParameterStyle = 'matrix' | 'label' | 'form' | 'simple' | 'spaceDelimited' | 'pipeDelimited' | 'deepObject';
+
+declare interface OpenAPIPath extends Partial<OpenAPIRef>, ParsedDescriptionWithSummary {
+    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>>;
+}
+
+declare interface OpenAPIPaths {
+    [path: string]: OpenAPIPath;
+}
+
+declare interface OpenAPIRef extends ParsedDescriptionWithSummary {
+    $ref: string;
+    'x-refsStack'?: string[];
+    summary?: string;
+    description?: string;
+}
+
+declare interface OpenAPIRequestBody extends ParsedDescription {
+    description?: string;
+    required?: boolean;
+    content: {
+        [mime: string]: OpenAPIMediaType;
+    };
+    'x-examples'?: {
+        [mime: string]: {
+            [name: string]: Referenced<OpenAPIExample>;
+        };
+    };
+    'x-example'?: {
+        [mime: string]: any;
+    };
+}
+
+declare interface OpenAPIResponse extends ParsedDescription {
+    description?: string;
+    headers?: {
+        [name: string]: Referenced<OpenAPIHeader>;
+    };
+    content?: {
+        [mime: string]: OpenAPIMediaType;
+    };
+    links?: {
+        [name: string]: Referenced<OpenAPILink>;
+    };
+    'x-examples'?: {
+        [mime: string]: {
+            [name: string]: Referenced<OpenAPIExample>;
+        };
+    };
+    'x-example'?: {
+        [mime: string]: any;
+    };
+}
+
+declare interface OpenAPIResponses {
+    [code: string]: OpenAPIResponse;
+}
+
+declare interface OpenAPISchema extends ParsedDescription {
+    $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;
+    examples?: any[];
+    const?: string;
+    contentEncoding?: string;
+    contentMediaType?: string;
+    if?: OpenAPISchema;
+    else?: OpenAPISchema;
+    then?: OpenAPISchema;
+    prefixItems?: OpenAPISchema[];
+    additionalItems?: OpenAPISchema | boolean;
+    xml?: XMLObject;
+}
+
+declare interface OpenAPISecurityRequirement {
+    [name: string]: string[];
+}
+
+declare interface OpenAPISecurityScheme extends ParsedDescription {
+    type: 'apiKey' | 'http' | 'oauth2' | 'openIdConnect';
+    description?: string;
+    name?: string;
+    in?: 'query' | 'header' | 'cookie';
+    scheme?: string;
+    bearerFormat: string;
+    'x-defaultClientId'?: string;
+    flows: {
+        implicit?: {
+            refreshUrl?: string;
+            scopes: Record<string, string>;
+            authorizationUrl: string;
+            'x-defaultClientId'?: string;
+        };
+        password?: {
+            refreshUrl?: string;
+            scopes: Record<string, string>;
+            tokenUrl: string;
+            'x-defaultClientId'?: string;
+        };
+        clientCredentials?: {
+            refreshUrl?: string;
+            scopes: Record<string, string>;
+            tokenUrl: string;
+            'x-defaultClientId'?: string;
+            'x-assertionType'?: 'urn:ietf:params:oauth:client-assertion-type:jwt-bearer';
+        };
+        authorizationCode?: {
+            refreshUrl?: string;
+            scopes: Record<string, string>;
+            authorizationUrl: string;
+            tokenUrl: string;
+            'x-defaultClientId'?: string;
+        };
+    };
+    openIdConnectUrl?: string;
+}
+
+declare interface OpenAPIServer extends ParsedDescription {
+    url: string;
+    description?: string;
+    variables?: OpenAPIServerVariables;
+}
+
+declare interface OpenAPIServerVariable extends ParsedDescription {
+    enum?: string[];
+    default: string;
+    description?: string;
+}
+
+declare interface OpenAPIServerVariables {
+    [name: string]: OpenAPIServerVariable;
+}
+
+declare interface OpenAPITag extends ParsedDescription {
+    name: string;
+    description?: string;
+    externalDocs?: OpenAPIExternalDocumentation;
+    'x-displayName'?: string;
+    'x-rbac'?: Record<string, unknown>;
+}
+
+declare interface OpenAPIXBadges {
+    name: string;
+    color?: string;
+    position?: 'before' | 'after';
+}
+
 declare function openFile({ name, extensions, multiple, }: {
     name: string;
     extensions: string[];
     multiple: boolean;
-}): Promise<FileResponse | string | null>;
+}): Promise<string[] | string | null>;
 
 declare type OperationIn = 'query' | 'header' | 'path' | 'cookie';
 
@@ -183,16 +550,26 @@ export declare type OperationSecurity = {
     'x-defaultPassword'?: string;
 };
 
+declare interface ParsedDescription {
+    'x-parsed-md-description'?: GenericObject;
+}
+
+declare interface ParsedDescriptionWithSummary extends ParsedDescription {
+    'x-parsed-md-summary'?: GenericObject;
+}
+
 declare type PasswordOAuthFlowsObject = {
     tokenUrl: string;
     scopes: Record<string, string>;
 };
 
+declare type Referenced<T> = T | OpenAPIRef;
+
 export declare function Replay(props: ReplayAppProps): JSX.Element;
 
 declare type ReplayAppProps = {
     activeOperationId?: string;
-    source?: Omit<Source, 'id'>;
+    api?: OpenAPIDefinition;
     settings: InputSettings;
 };
 
@@ -205,7 +582,7 @@ export declare type ReplayOnChangeParams = {
     }>;
 };
 
-export declare function ReplayOverlay({ onClose, onLoad, onRequestChange, ...props }: ReplayOverlayProps): JSX.Element;
+export declare function ReplayOverlay(props: ReplayOverlayProps): JSX.Element;
 
 declare type ReplayOverlayProps = {
     onClose: () => void;
@@ -216,6 +593,7 @@ declare type ReplayOverlayProps = {
 declare type Response_2 = ImmutableObject<{
     headers: [string, string][];
     cookies: [string, string][];
+    bodyNotStored?: boolean;
     body: string;
     duration: number;
     size: number;
@@ -238,22 +616,35 @@ declare type ServerVariable = {
     description?: string;
 };
 
-declare type Source = {
-    id: string;
-    type: 'openapi' | 'arazzo';
-    path?: string;
-    data: Record<string, any>;
-};
-
-declare type SourcePath = {
-    path: string;
-    method: string;
-};
-
 export declare const utils: {
     openFile: typeof openFile;
+    getAbsoluteProjectDir: typeof getAbsoluteProjectDir;
 };
 
+declare interface XLogo {
+    url?: string;
+    backgroundColor?: string;
+    altText?: string;
+    href?: string;
+}
+
+declare interface XMetadata {
+    apiId?: string;
+    [key: string]: unknown;
+}
+
+declare interface XMLObject {
+    name?: string;
+    namespace?: string;
+    prefix?: string;
+    attribute?: boolean;
+    wrapped?: boolean;
+}
+
+declare interface XSEO {
+    title?: string;
+}
+
 export { }
 
 declare global {