@apistudio/apim-cli/node_modules/@apic/studio-test/dist/models/interface.d.ts

CLI for API Management Products

/**
* Copyright Super iPaaS Integration LLC, an IBM Company 2024
*/
import { FormParamDefinition, RequestBodyDefinition } from 'postman-collection';
import { Test, Test_Headers, Test_Auth, Test_Raw, Test_UrlEncodedFormData, Test_Parameters, Test_FormData, Test_Payload, Test_Settings, Test_Assertions, Test_Request, Test_Environment, Test_Spec } from '@apic/api-model/test/Test.js';
import { Environment as EnvironmentKind, Environment_Spec } from '@apic/api-model/test/Environment.js';
import { Assertion } from '@apic/api-model/test/Assertion.js';
import { Assert } from '@apic/api-model/test/common/Assert.js';
import { Variable } from '@apic/api-model/test/common/Variable.js';
import { Metadata } from '@apic/api-model/common/Metadata.js';
import { NewmanRunExecution } from 'newman';
import { GenericAssetAdaptor } from '@apic/api-model/adaptor/GenericAssetAdaptor.js';
import { AssertType } from '../service/assertMapper.js';
import { Ref } from '@apic/api-model/common/Ref.js';
export interface ExtendedNewmanRunExecution extends NewmanRunExecution {
    id?: string;
}
export interface ExtendedRequestBodyDefinition extends RequestBodyDefinition {
    options?: {
        raw: {
            language: string;
        };
    };
}
export interface ExtendedFormParamDefinition extends FormParamDefinition {
    type?: string;
    src?: string;
}
export type Environment = Required<EnvironmentKind>;
export type TestSpec = Required<Test>;
export type RequestHeader = Required<Test_Headers>;
export type RequestAuth = Partial<Test_Auth>;
export type RawData = Partial<Test_Raw>;
export type UrlEncodedFormDataItem = Required<Test_UrlEncodedFormData>;
export type RequestParameter = Required<Test_Parameters>;
export type FormDataItem = Required<Test_FormData>;
export type RequestBodyObject = Partial<Test_Payload>;
export type RequestSettting = Partial<Test_Settings>;
export type ExpType = Required<Assert>;
export type Assertions = Partial<Test_Assertions>;
export type TestAssertion = Required<Assertion>;
export type RequestItem = Required<Test_Request>;
export type TestEnvironment = Partial<Test_Environment>;
export type EnvironmentVariable = Required<Variable>;
export type ApiReference = Required<Ref>;
export type Spec = Required<Test_Spec>;
export type Env_Spec = Required<Environment_Spec>;
export type TestMetadata = Required<Metadata>;
export interface SpecObject {
    [key: string]: SpecObject | string;
}
export interface ErrorResponse {
    code: string;
    field: string;
    description: string;
}
export type YamlContent = Required<GenericAssetAdaptor>;
export interface TestManagerInterface {
    processFile(buffer: Buffer): Promise<unknown[] | null>;
}
export interface IConverter {
    toString(input: number): string;
}
export interface AssetManagerInterface {
    createAssetReferenceMap(buffer: Buffer): Promise<Map<string, boolean>>;
    updateMapWithMetadata(yamlContent: YamlContent, refMap: Map<string, boolean>): void;
    updateMapWithGatewayEndpoints(data: Buffer, refMap: Map<string, boolean>): Promise<void>;
}
export interface YamlValidatorInterface {
    validateYamlFiles(buffer: Buffer): Promise<boolean>;
}
export interface RefParserInterface {
    parseRef(ref: string): {
        namespace?: string;
        name: string;
        version: string;
    };
}
export interface IGatewayAssetHandler {
    getApiEndpoints(key: string): Promise<string[]>;
}
export interface IZipManager {
    getEntryByName(entryName: string): Promise<string | undefined>;
}
export interface ICollectionCreator {
    createCollection(parsedData: TestSpec, fileBuffer: Buffer): Promise<PostmanCollection>;
}
export interface PostmanCollection {
    info: {
        name: string;
        version: string;
        schema: string;
    };
    item: Array<{
        name: string;
        event: Array<{
            listen: string;
            script: {
                exec: string[];
            };
        }>;
        protocolProfileBehavior?: {
            disableUrlEncoding?: boolean;
            strictSSL?: boolean;
        };
        request: {
            url: {
                raw: string;
                protocol: string;
                host: string[];
                path: string[];
                port?: string;
                query?: Array<{
                    key: string;
                    value: string;
                }>;
            };
            method: string;
            header: Array<{
                key: string;
                value: string;
            }>;
            body?: {
                mode: string;
                raw?: string;
                formdata?: Array<{
                    key: string;
                    value?: string;
                    src?: string;
                    type: string;
                }>;
                urlencoded?: Array<{
                    key: string;
                    value: string;
                }>;
            };
            auth?: {
                type: string;
                basic?: Array<{
                    key: string;
                    value: string;
                }>;
                bearer?: Array<{
                    key: string;
                    value: string;
                }>;
            };
        };
    }>;
}
export interface IAssertMapper {
    converttoAssertionStructure(yamlObject: AssertType): string;
    getAssertionModel(name: string, key: string, value: any, action: string): string;
}
//# sourceMappingURL=interface.d.ts.map