import { Request as Request$1, RequestHandler, Express } from 'express';
import winston from 'winston';
import { IncomingMessage, ServerResponse, ClientRequest, Server } from 'http';
import { ICredentials, IAuthentication, Client, IFetchResponse, IResult, IResultList, IFetchOptions } from '@c8y/client';
import { FormatFn } from 'morgan';

/**
 * Preprocessor for C8yPact objects. Use C8yPactPreprocessor to preprocess any
 * Cypress.Response, C8yPactRecord or C8yPact. The preprocessor could be used to
 * obfuscate or remove sensitive data from the pact objects. It is called on save
 * and load of the pact objects.
 */
interface C8yPactPreprocessor {
    /**
     * Configuration options used by the preprocessor.
     */
    readonly options?: C8yPactPreprocessorOptions;
    /**
     * Applies the preprocessor to the given object.
     *
     * @param obj Object to preprocess.
     * @param options Preprocessor options.
     */
    apply: (obj: Partial<Cypress.Response<any> | C8yPactRecord | C8yPact>, options?: C8yPactPreprocessorOptions) => void;
}
/**
 * Configuration options for the C8yPactPreprocessor.
 */
interface C8yPactPreprocessorOptions {
    /**
     * Key paths to obfuscate.
     *
     * @example
     * response.body.password
     */
    obfuscate?: string[];
    /**
     * Key paths to remove.
     *
     * @example
     * request.headers.Authorization
     */
    ignore?: string[];
    /**
     * Key paths to pick. All other keys (children) of the object will
     * be removed.
     *
     * @example
     * response.headers: ["content-type"]
     * ["request.headers", "response.headers"]
     */
    pick?: {
        [key: string]: string[];
    } | string[];
    /**
     * Obfuscation pattern to use. Default is ********.
     */
    obfuscationPattern?: string;
    /**
     * Whether to ignore case when matching keys.
     */
    ignoreCase?: boolean;
}
declare const C8yPactPreprocessorDefaultOptions: {
    ignore: string[];
    obfuscate: string[];
    obfuscationPattern: string;
    ignoreCase: boolean;
};
/**
 * Default implementation of C8yPactPreprocessor. Preprocessor for C8yPact objects
 * that can be used to obfuscate or remove sensitive data from the pact objects.
 * Use C8ypactPreprocessorOptions to configure the preprocessor.
 *
 * Removes cookies and set-cookie headers by appending the key to the `cookie` or `set-cookie`
 * key as for example `headers.cookie.authorization` or `headers.set-cookie.authorization`.
 */
declare class C8yDefaultPactPreprocessor implements C8yPactPreprocessor {
    static defaultObfuscationPattern: string;
    options?: C8yPactPreprocessorOptions;
    protected reservedKeys: string[];
    constructor(options?: C8yPactPreprocessorOptions);
    apply(obj: Partial<Cypress.Response<any> | C8yPactRecord | C8yPact>, options?: C8yPactPreprocessorOptions): void;
    private filterObjectByKeepPaths;
    private applyKeepArray;
    private handleObfuscation;
    private handleRemoval;
    private removeKey;
    private removeSetCookie;
    private removeCookie;
    private filterValidKeys;
    private obfuscateKey;
    private obfuscateSetCookie;
    private obfuscateCookie;
    protected resolveOptions(options?: Partial<C8yPactPreprocessorOptions>): C8yPactPreprocessorOptions;
    private hasKey;
    private getCookieObject;
}

interface C8yAuthOptions$1 extends ICredentials {
    sendImmediately?: boolean;
    bearer?: (() => string) | string;
    userAlias?: string;
    type?: string;
    xsrfToken?: string;
}
interface C8yPactAuthObject {
    userAlias?: string;
    user: string;
    type?: string;
}
type C8yAuthentication = IAuthentication;

/**
 * Matcher for matching objects against a schema. If the object does not match
 * the schema an Error will be thrown.
 */
interface C8ySchemaMatcher {
    /**
     * Matches the given object against the given schema. Throws an error when
     * schema does not match. Strict matching controls whether additional properties
     * are allowed in the object.
     *
     * @param obj Object to match.
     * @param schema Schema to match obj against.
     * @param strictMatching If true, additional properties are not allowed.
     */
    match(obj: any, schema: any, strictMatching?: boolean): boolean;
}
/**
 * A C8ySchemaGenerator is used to generate json schemas from json objects.
 */
interface C8ySchemaGenerator {
    /**
     * Generates a json schema for the given object.
     *
     * @param obj The object to generate the schema for.
     * @param options The options passed to the schema generator.
     */
    generate: (obj: any, options?: any) => Promise<any>;
}

/**
 * Tenant ID of a Cumulocity tenant.
 * @example t123456
 */
type C8yTenant = string;
/**
 * Base URL of a Cumulocity tenant.
 * @example https://tenant.eu-latest.cumulocity.com
 */
type C8yBaseUrl = string;

declare global {
    interface Response {
        data?: string | any;
        method?: string;
        responseObj?: Partial<Cypress.Response<any>>;
        requestBody?: string | any;
    }
    namespace Cypress {
        interface Response<T> {
            url?: string;
            requestBody?: string | any;
            method?: string;
            $body?: any;
        }
    }
}
/**
 * Options used to configure c8yclient command.
 */
type C8yClientOptions = Partial<Cypress.Loggable> & Partial<Cypress.Timeoutable> & Partial<Pick<Cypress.Failable, "failOnStatusCode">> & Partial<{
    auth: IAuthentication;
    baseUrl: C8yBaseUrl;
    client: Client;
    preferBasicAuth: boolean;
    skipClientAuthentication: boolean;
    failOnPactValidation: boolean;
    ignorePact: boolean;
    schema: any;
    record: C8yPactRecord;
    schemaMatcher: C8ySchemaMatcher;
    strictMatching: boolean;
}>;
/**
 * Wrapper for Client to pass auth and options without extending Client.
 * Using underscore to avoid name clashes with Client and misunderstandings reading the code.
 */
interface C8yClient {
    _auth?: C8yAuthentication;
    _options?: C8yClientOptions;
    _client?: Client;
}
/**
 * C8yAuthOptions is used to configure the authentication for the cy.c8yclient command. It is
 * an extension of the ICredentials interface from the @c8y/client package adding
 * userAlias and type property.
 */
interface C8yAuthOptions extends ICredentials {
    sendImmediately?: boolean;
    bearer?: (() => string) | string;
    userAlias?: string;
    type?: string;
}
/**
 * Converts the given object to a Cypress.Response.
 * @param obj The object to convert.
 * @param duration The duration of the request.
 * @param fetchOptions The fetch options used for the request.
 * @param url The URL of the request.
 * @param schema The schema of the response.
 */
declare function toCypressResponse(obj: IFetchResponse | IResult<any> | IResultList<any> | C8yPactRecord | Partial<Response>, duration?: number, fetchOptions?: IFetchOptions, url?: RequestInfo | URL, schema?: any): Cypress.Response<any> | undefined;
/**
 * Checks if the given object is a window.Response.
 * @param obj The object to check.
 */
declare function isWindowFetchResponse(obj: any): obj is Response;
/**
 * Checks if the given object is an IResult.
 * @param obj The object to check.
 */
declare function isIResult(obj: any): obj is IResult<any>;
/**
 * Checks if the given object is a CypressError.
 * @param error The object to check.
 * @returns True if the object is a CypressError, false otherwise.
 */
declare function isCypressError(error: any): boolean;
declare function oauthLogin(auth: C8yAuthOptions, baseUrl?: C8yBaseUrl): Promise<C8yAuthOptions>;

declare const C8yPactModeValues: readonly ["record", "recording", "apply", "forward", "disabled", "mock"];
/**
 * The pact mode is used to determine the behavior of the recording and mocking capabilities.
 * - `record`: Records the requests and responses and stores them in a pact file.
 * - `apply`: Mocks or matches the requests and responses from the recorded pact file.
 * - `disabled`: Disables the pact recording and mocking (same as undefined).
 * - `forward`: Forward requests without recording or mocking (might not be supported in all contexts).
 * - `recording` (deprecated): same as `record`, use `record` instead.
 * - `mock`: Mock responses for requests. Same as `apply`, but `apply` could also mean matching the requests and responses depending on the context.
 */
type C8yPactMode = (typeof C8yPactModeValues)[number];
declare const C8yPactRecordingModeValues: readonly ["refresh", "append", "new", "replace"];
/**
 * The pact recording mode is used to determine how or if requests and responses are recorded.
 * - `refresh` (default): Recreates the pact file with the all requests and responses.
 * - `append`: Appends the new requests and responses to the existing pact file.
 * - `new`: Only creates a new pact file if no pact file exists. If pact file exists, only new requests and responses are added.
 * - `replace`: Overwrites existing records of a pact with new request and response in the order of occurence. Other records are kept as is.
 */
type C8yPactRecordingMode = (typeof C8yPactRecordingModeValues)[number];
/**
 * ID representing a pact object. Should be unique.
 * @example api__get__permission_failure_tests
 */
type C8yPactID = string;
interface C8yPactRequestMatchingOptions {
    ignoreUrlParameters?: string[];
    baseUrl?: C8yBaseUrl;
}
interface C8yPactConfigOptions {
    /**
     * ID representing a pact object.
     */
    id?: C8yPactID;
    /**
     * Use to enable additional logging.
     */
    log?: boolean;
    /**
     * Information describing the producer of the pact. Includes name and version information
     */
    producer?: {
        name: string;
        version?: string;
    } | string;
    /**
     * Information describing the consumer of the pact. Includes name and version information
     */
    consumer?: {
        name: string;
        version?: string;
    } | string;
    /**
     * Tags describing the pact.
     */
    tags?: string[];
    /**
     * Description of the pact.
     */
    description?: string;
    /**
     * Use ignore to disable the pact for the current test case.
     */
    ignore?: boolean;
    /**
     * Use failOnMissingPacts to disable failing the test if no pact or no next record
     * is found for the current test case.
     */
    failOnMissingPacts?: boolean;
    /**
     * Use strictMatching to enable strict matching of the pact records. If strict matching
     * is enabled, all properties of the pact records must match and tests fail if a property
     * is missing. Default is false.
     */
    strictMatching?: boolean;
    /**
     * If strictMocking is enabled, an error will be thrown if no pact record matches the
     * current request. If disabled, the request will be passed through to the configured baseUrl.
     */
    strictMocking?: boolean;
    /**
     * Options to configure the C8yPactPreprocessor.
     */
    preprocessor?: C8yPactPreprocessorOptions;
    /**
     * Options to configure the C8yPact request matching.
     */
    requestMatching?: C8yPactRequestMatchingOptions;
    /**
     * Recording mode for the pact. Default is `refresh`.
     */
    recordingMode?: C8yPactRecordingMode;
}
type C8yPactConfigKeys = keyof C8yPactConfigOptions;
interface C8yPactEnv {
    tenant?: C8yTenant;
    loggedInUser?: string;
    loggedInUserAlias?: string;
    testTitlePath?: string[];
    systemVersion?: string;
    pluginVersion?: string;
    pluginFolder?: string;
}
/**
 * Pact object. Contains all information about a recorded pact, including
 * the pact records with requests and responses as well as info object with
 * meta data. A C8yPact objtect must have an unique id.
 */
interface C8yPact {
    /**
     * Pact records containing the requests and responses as well as auth information,
     * configuration options and created objects.
     */
    records: C8yPactRecord[];
    /**
     * Meta information describing the pact.
     */
    info: C8yPactInfo;
    /**
     * Unique id of the pact.
     */
    id: C8yPactID;
    /**
     * Clears all records of the pact. Also resets all indexes internally used for
     * iterating over the records.
     */
    clearRecords(): void;
    /**
     * Appends a new record to the pact. If skipIfExists is true, the record is
     * only appended if no record with the same request exists.
     * @param record The record to add.
     * @param skipIfExists If true, the record is only appended if no record for the same request exists.
     * @returns True if the record was appended, false otherwise.
     */
    appendRecord(record: C8yPactRecord, skipIfExists?: boolean): boolean;
    /**
     * Replaces an existing record with a new record. If no record with the same
     * request exists, the record is appended.
     * @param record The record to be replaced.
     * @returns True if the record was replaced, false otherwise.
     */
    replaceRecord(record: C8yPactRecord): boolean;
    /**
     * Returns the next pact record or null if no more records are available.
     */
    nextRecord(): C8yPactRecord | null;
    /**
     * Returns the next pact record matching the given request. Request matching is
     * based ob criteria like url and method. Returns null if no record is found.
     */
    nextRecordMatchingRequest(request: Partial<Request> | {
        url: string;
        method: string;
    }, baseUrl?: C8yBaseUrl): C8yPactRecord | null;
    /**
     * Returns an iterator for the pact records.
     */
    [Symbol.iterator](): Iterator<C8yPactRecord | null>;
}
interface C8yPactInfoVersion {
    system?: string;
    c8ypact?: string;
    runner?: string;
}
/**
 * Meta information describing a pact and how it was recorded.
 */
interface C8yPactInfo extends C8yPactConfigOptions {
    id: C8yPactID;
    /**
     * Version information of the system, runner and pact standard used to record the pact.
     */
    version?: {
        system?: string;
        shell?: string;
        shellName?: string;
        c8ypact?: string;
        runner?: string;
    };
    /**
     * Title of the pact. Title is an array of suite and test titles.
     */
    title?: string[];
    /**
     * Base URL when recording the pact.
     */
    baseUrl: C8yBaseUrl;
    /**
     * Tenant when recording the pact.
     */
    tenant?: C8yTenant;
}
/**
 * The request stored in a C8yPactRecord.
 */
type C8yPactRequest = Partial<Cypress.RequestOptions> & {
    $body?: any;
};
/**
 * The response stored in a C8yPactRecord.
 */
interface C8yPactResponse<T> {
    allRequestResponses?: any[];
    body?: T;
    duration?: number;
    headers?: {
        [key: string]: string | string[];
    };
    isOkStatusCode?: boolean;
    status?: number;
    statusText?: string;
    method?: string;
    $body?: any;
}
/**
 * The C8yPactRecord contains all information about a recorded request. It contains
 * the request and response as well as configuration options, auth information and
 * the created object id.
 */
interface C8yPactRecord {
    /**
     * Request of the record.
     */
    request: C8yPactRequest;
    /**
     * Response of the record.
     */
    response: C8yPactResponse<any>;
    /**
     * Modified response returned by interception RouteHandler.
     */
    modifiedResponse?: C8yPactResponse<any>;
    /**
     * Configuration options used for the request.
     */
    options?: C8yClientOptions;
    /**
     * Auth information used for the request. Can be Basic or Cookie auth. Contains username and possibly alias.
     */
    auth?: C8yPactAuthObject;
    /**
     * Id of an object created by the request. Used for mapping when running the recording.
     */
    createdObject?: string;
    /**
     * Converts the C8yPactRecord to a Cypress.Response object.
     */
    toCypressResponse(): Cypress.Response<any>;
    /**
     * Returns the date of the response.
     */
    date(): Date | null;
    /**
     * Returns if the record has a request header with the given key. Comparison is case-insensitive.
     */
    hasRequestHeader(key: string): boolean;
    /**
     * Returns the auth type of the record. Currently supports `BasicAuth`, `CookieAuth` or undefined.
     */
    authType(): "BasicAuth" | "CookieAuth" | "BearerAuth" | undefined;
}
declare function isValidPactId(value: string): boolean;
/**
 * Creates an C8yPactID for a given string or array of strings.
 * @param value The string or array of strings to convert to a pact id.
 * @returns The pact id.
 */
declare function pactId(value: string | string[]): C8yPactID | undefined;
/**
 * Validate the given pact mode. Throws an error if the mode is not supported
 * or undefined.
 * @param mode The pact mode to validate.
 */
declare function validatePactMode(mode?: string): void;
/**
 * Validate the given pact recording mode. Throws an error if the mode is not supported
 * or undefined.
 * @param mode The pact recording mode to validate.
 */
declare function validatePactRecordingMode(mode?: string): void;
/**
 * Checks if the given object is a C8yPact. This also includes checking
 * all records to be valid C8yPactRecord instances.
 *
 * @param obj The object to check.
 * @returns True if the object is a C8yPact, false otherwise.
 */
declare function isPact(obj: any): obj is C8yPact;
/**
 * Checks if the given object is a C8yPactRecord.
 *
 * @param obj The object to check.
 * @returns True if the object is a C8yPactRecord, false otherwise.
 */
declare function isPactRecord(obj: any): obj is C8yPactRecord;
/**
 * Checks if the given object is a Cypress.Response.
 *
 * @param obj The object to check.
 * @returns True if the object is a Cypress.Response, false otherwise.
 */
declare function isCypressResponse(obj: any): obj is Cypress.Response<any>;
/**
 * Checks if the given object is a C8yPactError. A C8yPactError is an error
 * with the name "C8yPactError".
 *
 * @param error The object to check.
 * @returns True if the object is a C8yPactError, false otherwise.
 */
declare function isPactError(error: any): boolean;
/**
 * Converts a Cypress.Response to a C8yPactRequest.
 */
declare function toPactRequest(response: Cypress.Response<any> | Partial<Cypress.Response<any>>): C8yPactRequest | undefined;
/**
 * Converts a Cypress.Response to a C8yPactResponse.
 */
declare function toPactResponse<T>(response: Cypress.Response<T> | Partial<Cypress.Response<T>>): C8yPactResponse<T> | undefined;
type C8yPactSaveKeys = "id" | "info" | "records";
/**
 * Returns the value of the environment variable with the given name. The function
 * tries to find the value in the global `process.env` or `Cypress.env()`. If `env`
 * is provided, the function uses the given object as environment.
 *
 * The function tries to find the value in the following order:
 * - `name`
 * - `camelCase(name)`
 * - `CYPRESS_name`
 * - `name.replace(/^C8Y_/i, "")`
 * - `CYPRESS_camelCase(name)`
 * - `CYPRESS_camelCase(name.replace(/^C8Y_/i, ""))`
 *
 * @param name The name of the environment variable.
 * @param env The environment object to use. Default is `process.env` or `Cypress.env()`
 *
 * @returns The value of the environment variable or `undefined` if not found.
 */
declare function getEnvVar(name: string, env?: {
    [key: string]: string;
}): string | undefined;
declare function isOneOfStrings(value: string, values: string[]): boolean;

/**
 * Default implementation of C8yPact. Use C8yDefaultPact.from to create a C8yPact from
 * a Cypress.Response object, a serialized pact as string or an object implementing the
 * C8yPact interface. Note, objects implementing the C8yPact interface may not provide
 * all required functions and properties.
 */
declare class C8yDefaultPact implements C8yPact {
    records: C8yPactRecord[];
    info: C8yPactInfo;
    id: C8yPactID;
    protected recordIndex: number;
    protected iteratorIndex: number;
    protected requestIndexMap: {
        [key: string]: number;
    };
    static strictMatching: boolean;
    constructor(records: C8yPactRecord[], info: C8yPactInfo, id: C8yPactID);
    /**
     * Creates a C8yPact from a Cypress.Response object, a serialized pact as string
     * or an object containing the pact records and info object. Throws an error if
     * the input can not be converted to a C8yPact.
     * @param obj The Cypress.Response, string or object to create a pact from.
     * @param info The C8yPactInfo object containing additional information for the pact.
     * @param client The optional C8yClient for options and auth information.
     */
    static from(...args: [obj: Cypress.Response<any>, info: C8yPactInfo, client?: C8yClient] | [obj: string | C8yPact]): C8yDefaultPact;
    clearRecords(): void;
    appendRecord(record: C8yPactRecord, skipIfExists?: boolean): boolean;
    replaceRecord(record: C8yPactRecord): boolean;
    /**
     * Returns the next pact record or null if no more records are available.
     */
    nextRecord(): C8yPactRecord | null;
    nextRecordMatchingRequest(request: Partial<Request> | {
        url: string;
        method: string;
    }, baseUrl?: C8yBaseUrl): C8yPactRecord | null;
    protected getIndexForKey(key: string): number;
    protected setIndexForKey(key: string, index: number): void;
    protected indexMapKey(request: Partial<Request> | C8yPactRequest, baseUrl?: C8yBaseUrl): string | undefined;
    protected normalizeUrl(url: string | URL, parametersToRemove?: string[], baseUrl?: C8yBaseUrl): string;
    protected matchUrls(url1: string | URL, url2: string | URL, baseUrl?: C8yBaseUrl): boolean;
    protected getRequesIndex(key: string): number;
    /**
     * Returns the pact record for the given request or null if no record is found.
     * Currently only url and method are used for matching.
     * @param req The request to use for matching.
     */
    getRecordsMatchingRequest(req: Partial<Request> | C8yPactRequest, baseUrl?: C8yBaseUrl): C8yPactRecord[] | null;
    /**
     * Returns an iterator for the pact records to iterate records using `for (const record of pact) {...}`.
     */
    [Symbol.iterator](): Iterator<C8yPactRecord | null>;
}
type C8yPactSerializeOptions = {
    preprocessor?: C8yPactPreprocessor;
    client?: C8yClient;
    modifiedResponse?: Cypress.Response<any>;
    schemaGenerator?: C8ySchemaGenerator;
    loggedInUser?: string;
    loggedInUserAlias?: string;
    authType?: string;
    baseUrl?: C8yBaseUrl;
};
declare function toSerializablePactRecord(response: Partial<Cypress.Response<any>>, options?: C8yPactSerializeOptions): C8yPactRecord;
declare function toPactSerializableObject(response: Partial<Cypress.Response<any>>, info: C8yPactInfo, options?: C8yPactSerializeOptions): Promise<Pick<C8yPact, C8yPactSaveKeys>>;

/**
 * Default implementation of C8yPactRecord. Use C8yDefaultPactRecord.from to create
 * a C8yPactRecord from a Cypress.Response object or an C8yPactRecord object.
 */
declare class C8yDefaultPactRecord implements C8yPactRecord {
    request: C8yPactRequest;
    response: C8yPactResponse<any>;
    options?: C8yClientOptions;
    auth?: C8yPactAuthObject;
    createdObject?: string;
    modifiedResponse?: C8yPactResponse<any>;
    constructor(request: C8yPactRequest, response: C8yPactResponse<any>, options?: C8yClientOptions, auth?: C8yPactAuthObject, createdObject?: string, modifiedResponse?: C8yPactResponse<any>);
    /**
     * Creates a C8yPactRecord from a Cypress.Response or an C8yPactRecord object.
     * @param obj The Cypress.Response<any> or C8yPactRecord object.
     * @param client The C8yClient for options and auth information.
     */
    static from(obj: Cypress.Response<any> | C8yPactRecord | Partial<Cypress.Response<any>>, auth?: C8yAuthOptions$1, client?: C8yClient): C8yPactRecord;
    /**
     * Returns the date of the response.
     */
    date(): Date | null;
    /**
     * Converts the C8yPactRecord to a Cypress.Response object.
     */
    toCypressResponse<T>(): Cypress.Response<T>;
    hasRequestHeader(key: string): boolean;
    authType(): "BasicAuth" | "CookieAuth" | undefined;
}
declare function createPactRecord(response: Partial<Cypress.Response<any>>, client?: C8yClient, options?: {
    loggedInUser?: string;
    loggedInUserAlias?: string;
    authType?: string;
}): C8yPactRecord;

/**
 * Matcher for C8yPactRecord objects. Use C8yPactMatcher to match any two
 * records. Depending on the matcher implementation an Error will be thrown
 * or boolean is returned.
 */
interface C8yPactMatcher {
    /**
     * Matches objectToMatch against objectPact. Returns false if objectToMatch
     * does not match objectPact or throws an error with details on failing match.
     *
     * @param obj1 Object to match.
     * @param obj2 Pact to match obj1 against.
     * @param {C8yPactMatcherOptions} options The C8yPactMatcherOptions to use for matching.
     */
    match: (objectToMatch: any, objectPact: any, options?: C8yPactMatcherOptions) => boolean;
}
interface C8yPactMatcherOptions {
    strictMatching?: boolean;
    loggerProps?: {
        [key: string]: any;
    };
    schemaMatcher?: C8ySchemaMatcher;
    parents?: string[];
    ignoreCase?: boolean;
}
/**
 * Default implementation of C8yPactMatcher to match C8yPactRecord objects. Pacts
 * are matched by comparing the properties of the objects using property matchers.
 * If no property matcher is configured for a property, the property will be matched
 * by equality. Disable Cypress.c8ypact.config.strictMatching to ignore properties that are
 * missing in matched objects. In case objects do not match an C8yPactError is thrown.
 */
declare class C8yDefaultPactMatcher implements C8yPactMatcher {
    propertyMatchers: {
        [key: string]: C8yPactMatcher;
    };
    static schemaMatcher: C8ySchemaMatcher;
    constructor(propertyMatchers?: {
        [key: string]: C8yPactMatcher;
    });
    match(obj1: any, obj2: any, options?: C8yPactMatcherOptions): boolean;
    /**
     * Returns the property matcher for the given property name.
     * @param key The property name to get the matcher for.
     * @param ignoreCase Whether to ignore the case of the property name.
     */
    getPropertyMatcher(key: string, ignoreCase?: boolean): any;
    /**
     * Adds a new property matcher for the given property name.
     */
    addPropertyMatcher(propertyName: string, matcher: C8yPactMatcher): void;
    /**
     * Removes the property matcher for the given property name.
     */
    removePropertyMatcher(propertyName: string): void;
}
/**
 * Extends C8yDefaultPactMatcher with default property matchers for Cumulocity
 * response bodies. It has rules configured at least for the following properties:
 * id, statistics, lastUpdated, creationTime, next, self, password, owner, tenantId
 * and lastPasswordChange. It is registered for the properties body and requestBody.
 */
declare class C8yPactBodyMatcher extends C8yDefaultPactMatcher {
    constructor(propertyMatchers?: {});
}
declare class C8yIdentifierMatcher implements C8yPactMatcher {
    match(obj1: any, obj2: any): boolean;
}
declare class C8yNumberMatcher implements C8yPactMatcher {
    match(obj1: any, obj2: any): boolean;
}
declare class C8yStringMatcher implements C8yPactMatcher {
    match(obj1: any, obj2: any): boolean;
}
declare class C8yIgnoreMatcher implements C8yPactMatcher {
    match(): boolean;
}
declare class C8ySameTypeMatcher implements C8yPactMatcher {
    match(obj1: any, obj2: any): boolean;
}
declare class C8yISODateStringMatcher {
    match(obj1: any, obj2: any): boolean;
}

/**
 * Using C8yPactFileAdapter you can implement your own adapter to load and save pacts using any format you want.
 * This allows loading pact objects from different sources, such as HAR files, pact.io, etc.
 *
 * The default adapter is C8yPactDefaultFileAdapter which loads and saves pact objects from/to
 * json files using C8yPact objects. Default location is cypress/fixtures/c8ypact folder.
 */
interface C8yPactFileAdapter {
    /**
     * Loads all pact objects. The key must be the pact id used in C8yPact.id.
     */
    loadPacts: () => {
        [key: string]: C8yPact;
    };
    /**
     * Loads a pact object by id from file.
     */
    loadPact: (id: string) => C8yPact | null;
    /**
     * Saves a pact object.
     */
    savePact: (pact: C8yPact) => void;
    /**
     * Deletes a pact object or file.
     */
    deletePact: (id: string) => void;
    /**
     * Gets the folder where the pact files are stored.
     */
    getFolder: () => string;
    /**
     * Checks if a pact exists for a given id.
     */
    pactExists(id: string): boolean;
    /**
     * Provides some custom description of the adapter.
     * @example C8yPactFileAdapter
     */
    description(): string;
}

type LogFormat = "json" | "simple" | "combined" | "short" | "dev" | "tiny" | "common";
type C8yPactHttpResponse<T = any> = Pick<C8yPactResponse<T>, "status" | "statusText" | "body" | "headers">;
declare const C8yPactHttpControllerLogLevel: readonly ["info", "debug", "warn", "error"];
declare const C8yPactHttpControllerDefaultMode: C8yPactMode;
declare const C8yPactHttpControllerDefaultRecordingMode: C8yPactRecordingMode;
interface C8yPactHttpControllerOptions {
    /**
     * The resource path to use for the controller. Default is "/c8yctrl".
     */
    resourcePath?: string;
    /**
     * Base URL of the target server to proxy requests to.
     */
    baseUrl?: C8yBaseUrl;
    /**
     * Authentication options to use for authenticating against the target server.
     */
    auth?: C8yAuthOptions$1;
    /**
     * Hostname to listen on. Default is localhost.
     */
    hostname?: string;
    /**
     * Port to listen on. Default is 3000.
     */
    port?: number;
    /**
     * Tenant id of the target server to proxy requests to.
     */
    tenant?: C8yTenant;
    /**
     * Root folder for static files to serve.
     */
    staticRoot?: string;
    /**
     * Adapter to use for loading and saving pact files.
     */
    adapter: C8yPactFileAdapter;
    /**
     * Preprocessor to use for modifying requests and responses.
     */
    preprocessor?: C8yPactPreprocessor;
    /**
     * Schema generator to use for generating schemas for response bodies. If not set, no schema is generated.
     */
    schemaGenerator?: C8ySchemaGenerator;
    /**
     * Request matching options to use for matching requests to recorded responses.
     */
    requestMatching?: C8yPactRequestMatchingOptions;
    /**
     * Enable strict mocking. If true, only recorded responses are returned.
     */
    strictMocking?: boolean;
    /**
     * Mode the controller is running in.
     */
    mode?: C8yPactMode;
    /**
     * Recording mode to use for recording requests and responses.
     */
    recordingMode?: C8yPactRecordingMode;
    /**
     * Id of the pact to use for recording and mocking. Default is undefined.
     */
    pactId?: C8yPactID;
    /**
     * Record to use for error responses when no mock is found.
     */
    mockNotFoundResponse?: C8yPactHttpResponse | ((req: Request$1<any, any, any, any>) => C8yPactHttpResponse);
    /**
     * Logger to use for logging. Currently only winston is supported.
     */
    logger?: winston.Logger;
    /**
     * RequestHandler to use for logging requests. Default is morgan.
     */
    requestLogger?: RequestHandler[] | ((logger?: winston.Logger) => RequestHandler[]);
    /**
     * RequestHandler to use for logging errors. Default is morgan logger
     * that logs error object with url, status, request and response details.
     * Use "common", "combined", "dev", "short" or "tiny" to use predefined
     * mporgan log formats.
     */
    errorLogger?: RequestHandler | "common" | "combined" | "dev" | "short" | "tiny" | string;
    /**
     * Log level to use for logging. Default is info.
     */
    logLevel?: (typeof C8yPactHttpControllerLogLevel)[number];
    /**
     * Log format to use for logging.
     */
    logFormat?: LogFormat | string | FormatFn<IncomingMessage, ServerResponse<IncomingMessage>>;
    /**
     * The app names and version to use from static folder. E.g. "cockpit: 1020".
     * The version must be a semver range.
     * @example { "cockpit": ">1020.0.0", "dtm": "^1018.1.0" }
     */
    appsVersions?: {
        [key: string]: string;
    };
    /**
     * Custom replacer function to use for JSON.stringify. Use for customization of JSON output.
     * Default is to replace URLs in "self", "next", "initRequest" properties with hostname and
     * port of the controller.
     */
    stringifyReplacer?: (key: string, value: any) => any;
    /**
     * Callbacks for hooking into the controller lifecycle.
     */
    on: C8yPactHttpControllerCallbackOptions;
}
interface C8yPactHttpControllerCallbackOptions {
    /**
     * Called before the controller is started.
     * @param ctrl The controller instance.
     * @param config The configuration used for the controller.
     */
    beforeStart?: (ctrl: C8yPactHttpController, config?: C8yPactHttpControllerOptions) => void;
    /**
     * Called before a request is mocked. Use to modify or return custom response as mock. Also
     * use to forward custom headers from the request to the response. By default, only the
     * recorded `content-type` and `set-cookie` headers are forwarded. Any other recorded headers
     * must be forwarded by adding them to the `response.headers` object.
     *
     * By returning null or undefined, the request is passed to the proxy handler without mocking.
     *
     * **Note**: return `record.response` to use the recorded response as mock.
     *
     * @param ctrl The controller instance.
     * @param req The request to mock.
     * @param record The record used for mocking.
     * @returns A response to use as mock or null/undefined to pass the request to the proxy handler.
     */
    mockRequest?: (ctrl: C8yPactHttpController, req: Request$1<any, any, any, any>, record: C8yPactRecord | undefined | null) => C8yPactHttpResponse | undefined | null;
    /**
     * Called when a request is not found in the recorded pacts. Use to return a custom response
     * for the request or `undefined` if `mockNotFoundResponse` or default 404 response should
     * be returned for the given request. To access the pact, the response was not found in, use
     * `c8yctl.currentPact`.
     * @param ctrl The controller instance.
     * @param req The request to be mocked.
     * @returns A response to use as mock for the request or `undefined` to use the default 404 response.
     */
    mockNotFound?: (ctrl: C8yPactHttpController, req: Request$1) => C8yPactHttpResponse | undefined;
    /**
     * Called before a request is proxied. Use to modify the request before it
     * is proxied, e.g. to add or remove headers, etc. or to abort the request
     * by returning a custom or error response to send back to the client.
     * @param ctrl The controller instance.
     * @param proxyReq The proxy request.
     * @param req The request to proxy.
     * @returns A response to send back to the client to abort the request or undefined to continue.
     */
    proxyRequest?: (ctrl: C8yPactHttpController, proxyReq: ClientRequest, req: Request$1<any, any, any, any>) => C8yPactHttpResponse | undefined | null;
    /**
     * Called after receiving the response for a proxied request. By returning false,
     * the request and response are ignored and not processed and saved. Use to filter
     * requests and responses from recording.
     * @param ctrl The controller instance.
     * @param req The proxied request.
     * @param res The proxied response.
     * @returns false if the request and response should be ignored, true otherwise.
     */
    proxyResponse?: (ctrl: C8yPactHttpController, req: Request$1, res: C8yPactHttpResponse) => boolean;
    /**
     * Called before a request and its response are saved. By returning false, the
     * request is ignored and not saved.
     * @param ctrl The controller instance.
     * @param req The C8yPact object to be saved.
     * @returns true if the C8yPact should be saved, false otherwise.
     */
    savePact?: (ctrl: C8yPactHttpController, pact: C8yPact) => boolean;
}
interface C8yPactHttpControllerConfig extends C8yPactHttpControllerOptions {
    /**
     * Folder to load and save pact files from and to.
     */
    folder?: string;
    /**
     * Folder to save log files to.
     */
    logFolder?: string;
    /**
     * Log file name to use for logging.
     */
    logFilename?: string;
    /**
     * File to use for http access logging.
     */
    accessLogFilename?: string;
    /**
     * User to login to the target server.
     */
    user?: string;
    /**
     * Password to login to the target server.
     */
    password?: string;
    /**
     * Enable or disable logging.
     */
    log?: boolean;
}
type C8yCtrlHeader = "x-c8yctrl-type" | "x-c8yctrl-id" | "x-c8yctrl-count" | "x-c8yctrl-mode";

declare class C8yPactHttpController {
    currentPact?: C8yDefaultPact;
    readonly port: number;
    readonly hostname: string;
    protected _baseUrl?: C8yBaseUrl;
    protected _staticRoot?: string;
    readonly tenant?: C8yTenant;
    adapter?: C8yPactFileAdapter;
    protected _recordingMode: C8yPactRecordingMode;
    protected _mode: C8yPactMode;
    protected _isStrictMocking: boolean;
    protected staticApps: {
        [key: string]: string;
    };
    protected authOptions?: C8yAuthOptions$1;
    protected server?: Server;
    readonly app: Express;
    readonly options: C8yPactHttpControllerOptions;
    readonly resourcePath: string;
    readonly logger: winston.Logger;
    protected mockHandler?: RequestHandler;
    protected proxyHandler?: RequestHandler;
    constructor(options: C8yPactHttpControllerOptions);
    /**
     * Base URL of the target server to proxy requests to.
     * @example "https://mytenant.eu-latest.cumulocity.com"
     */
    get baseUrl(): string | undefined;
    /**
     * Root folder for static files to serve. The controller will serve static files from this folder.
     * @example "/path/to/static/root"
     */
    get staticRoot(): string | undefined;
    get recordingMode(): C8yPactRecordingMode;
    set recordingMode(mode: C8yPactRecordingMode);
    get mode(): C8yPactMode;
    set mode(mode: C8yPactMode);
    isRecordingEnabled(): boolean;
    isMockingEnabled(): boolean;
    /**
     * Starts the server. When started, the server listens on the configured port and hostname. If required,
     * the server will try to login to the target server using the provided credentials. If authOptions have
     * a bearer token, the server will use this token for authentication. To enforce BasicAuth, set the type
     * property of the authOptions to "BasicAuth".
     */
    start(): Promise<void>;
    /**
     * Stops the server.
     */
    stop(): Promise<void>;
    protected registerOpenAPIRequestHandler(): void;
    protected registerStaticRootRequestHandler(): Promise<void>;
    protected registerC8yctrlInterface(): void;
    protected getStatus(): {
        status: string;
        uptime: number;
        version: any;
        adapter: string | null;
        baseUrl: string | null;
        tenant: string | null;
        current: {
            id: string | null;
        };
        static: {
            root: string | null;
            required: {
                [key: string]: string;
            } | null;
            apps: {
                [key: string]: string;
            };
        };
        mode: "record" | "recording" | "apply" | "forward" | "disabled" | "mock";
        supportedModes: readonly ["record", "recording", "apply", "forward", "disabled", "mock"];
        recording: {
            recordingMode: "replace" | "refresh" | "append" | "new";
            supportedRecordingModes: readonly ["refresh", "append", "new", "replace"];
            isRecordingEnabled: boolean;
        };
        mocking: {
            isMockingEnabled: boolean;
            strictMocking: boolean;
        };
        logger: {
            level: string;
        };
    };
    protected mockRequestHandler: RequestHandler;
    protected stringifyReplacer: (key: string, value: any) => any;
    getStringifyReplacer(): (key: string, value: any) => any;
    stringify(obj?: any): string;
    protected stringifyPact(pact: C8yDefaultPact | C8yPact | any): string;
    protected producerForPact(pact: C8yPact): {
        name: string;
        version?: string;
    } | undefined;
    protected pactsForProducer(pacts: {
        [key: string]: C8yDefaultPact;
    }, producer: string | {
        name: string;
        version: string;
    }, version?: string): C8yPact[];
    savePact(response: Cypress.Response<any> | C8yPact, pactForId?: C8yPact): Promise<boolean>;
    protected getObjectWithKeys(objs: any[], keys: string[]): any[];
}

export { type C8yClient, type C8yClientOptions, type C8yCtrlHeader, C8yDefaultPact, C8yDefaultPactMatcher, C8yDefaultPactPreprocessor, C8yDefaultPactRecord, C8yISODateStringMatcher, C8yIdentifierMatcher, C8yIgnoreMatcher, C8yNumberMatcher, type C8yPact, C8yPactBodyMatcher, type C8yPactConfigKeys, type C8yPactConfigOptions, type C8yPactEnv, C8yPactHttpController, type C8yPactHttpControllerCallbackOptions, type C8yPactHttpControllerConfig, C8yPactHttpControllerDefaultMode, C8yPactHttpControllerDefaultRecordingMode, C8yPactHttpControllerLogLevel, type C8yPactHttpControllerOptions, type C8yPactHttpResponse, type C8yPactID, type C8yPactInfo, type C8yPactInfoVersion, type C8yPactMatcher, type C8yPactMatcherOptions, type C8yPactMode, C8yPactModeValues, type C8yPactPreprocessor, C8yPactPreprocessorDefaultOptions, type C8yPactPreprocessorOptions, type C8yPactRecord, type C8yPactRecordingMode, C8yPactRecordingModeValues, type C8yPactRequest, type C8yPactRequestMatchingOptions, type C8yPactResponse, type C8yPactSaveKeys, type C8yPactSerializeOptions, C8ySameTypeMatcher, type C8ySchemaGenerator, type C8ySchemaMatcher, C8yStringMatcher, createPactRecord, getEnvVar, isCypressError, isCypressResponse, isIResult, isOneOfStrings, isPact, isPactError, isPactRecord, isValidPactId, isWindowFetchResponse, oauthLogin, pactId, toCypressResponse, toPactRequest, toPactResponse, toPactSerializableObject, toSerializablePactRecord, validatePactMode, validatePactRecordingMode };