/**
 * Cloudflare VULNERABILITY-SCANNER API
 *
 * Generated from Cloudflare TypeScript SDK.
 * DO NOT EDIT - regenerate with: bun scripts/generate.ts --service vulnerability-scanner
 */
import * as Schema from "effect/Schema";
import type * as HttpClient from "effect/unstable/http/HttpClient";
import * as API from "../client/api.ts";
import type { Credentials } from "../credentials.ts";
import { type DefaultErrors } from "../errors.ts";
export interface GetCredentialSetRequest {
    credentialSetId: string;
    /** Identifier. */
    accountId: string;
}
export declare const GetCredentialSetRequest: Schema.Schema<GetCredentialSetRequest>;
export interface GetCredentialSetResponse {
    /** Credential set identifier. */
    id: string;
    /** Human-readable name. */
    name: string;
}
export declare const GetCredentialSetResponse: Schema.Schema<GetCredentialSetResponse>;
export type GetCredentialSetError = DefaultErrors;
export declare const getCredentialSet: API.OperationMethod<GetCredentialSetRequest, GetCredentialSetResponse, GetCredentialSetError, Credentials | HttpClient.HttpClient>;
export interface ListCredentialSetsRequest {
    /** Path param: Identifier. */
    accountId: string;
    page?: number;
    perPage?: number;
}
export declare const ListCredentialSetsRequest: Schema.Schema<ListCredentialSetsRequest>;
export interface ListCredentialSetsResponse {
    result: {
        id: string;
        name: string;
    }[];
    resultInfo?: {
        count?: number | null;
        page?: number | null;
        perPage?: number | null;
        totalCount?: number | null;
    } | null;
}
export declare const ListCredentialSetsResponse: Schema.Schema<ListCredentialSetsResponse>;
export type ListCredentialSetsError = DefaultErrors;
export declare const listCredentialSets: API.PaginatedOperationMethod<ListCredentialSetsRequest, ListCredentialSetsResponse, ListCredentialSetsError, Credentials | HttpClient.HttpClient>;
export interface CreateCredentialSetRequest {
    /** Path param: Identifier. */
    accountId: string;
    /** Body param: Human-readable name. */
    name: string;
}
export declare const CreateCredentialSetRequest: Schema.Schema<CreateCredentialSetRequest>;
export interface CreateCredentialSetResponse {
    /** Credential set identifier. */
    id: string;
    /** Human-readable name. */
    name: string;
}
export declare const CreateCredentialSetResponse: Schema.Schema<CreateCredentialSetResponse>;
export type CreateCredentialSetError = DefaultErrors;
export declare const createCredentialSet: API.OperationMethod<CreateCredentialSetRequest, CreateCredentialSetResponse, CreateCredentialSetError, Credentials | HttpClient.HttpClient>;
export interface UpdateCredentialSetRequest {
    credentialSetId: string;
    /** Path param: Identifier. */
    accountId: string;
    /** Body param: Human-readable name. */
    name: string;
}
export declare const UpdateCredentialSetRequest: Schema.Schema<UpdateCredentialSetRequest>;
export interface UpdateCredentialSetResponse {
    /** Credential set identifier. */
    id: string;
    /** Human-readable name. */
    name: string;
}
export declare const UpdateCredentialSetResponse: Schema.Schema<UpdateCredentialSetResponse>;
export type UpdateCredentialSetError = DefaultErrors;
export declare const updateCredentialSet: API.OperationMethod<UpdateCredentialSetRequest, UpdateCredentialSetResponse, UpdateCredentialSetError, Credentials | HttpClient.HttpClient>;
export interface PatchCredentialSetRequest {
    credentialSetId: string;
    /** Path param: Identifier. */
    accountId: string;
    /** Body param: Human-readable name. */
    name?: string;
}
export declare const PatchCredentialSetRequest: Schema.Schema<PatchCredentialSetRequest>;
export interface PatchCredentialSetResponse {
    /** Credential set identifier. */
    id: string;
    /** Human-readable name. */
    name: string;
}
export declare const PatchCredentialSetResponse: Schema.Schema<PatchCredentialSetResponse>;
export type PatchCredentialSetError = DefaultErrors;
export declare const patchCredentialSet: API.OperationMethod<PatchCredentialSetRequest, PatchCredentialSetResponse, PatchCredentialSetError, Credentials | HttpClient.HttpClient>;
export interface DeleteCredentialSetRequest {
    credentialSetId: string;
    /** Identifier. */
    accountId: string;
}
export declare const DeleteCredentialSetRequest: Schema.Schema<DeleteCredentialSetRequest>;
export type DeleteCredentialSetResponse = unknown;
export declare const DeleteCredentialSetResponse: Schema.Schema<DeleteCredentialSetResponse>;
export type DeleteCredentialSetError = DefaultErrors;
export declare const deleteCredentialSet: API.OperationMethod<DeleteCredentialSetRequest, DeleteCredentialSetResponse, DeleteCredentialSetError, Credentials | HttpClient.HttpClient>;
export interface GetCredentialSetCredentialRequest {
    credentialSetId: string;
    credentialId: string;
    /** Identifier. */
    accountId: string;
}
export declare const GetCredentialSetCredentialRequest: Schema.Schema<GetCredentialSetCredentialRequest>;
export interface GetCredentialSetCredentialResponse {
    /** Credential identifier. */
    id: string;
    /** Parent credential set identifier. */
    credentialSetId: string;
    /** Where the credential is attached in outgoing requests. */
    location: "header" | "cookie" | (string & {});
    /** Name of the header or cookie where the credential is attached. */
    locationName: string;
    /** Human-readable name. */
    name: string;
}
export declare const GetCredentialSetCredentialResponse: Schema.Schema<GetCredentialSetCredentialResponse>;
export type GetCredentialSetCredentialError = DefaultErrors;
export declare const getCredentialSetCredential: API.OperationMethod<GetCredentialSetCredentialRequest, GetCredentialSetCredentialResponse, GetCredentialSetCredentialError, Credentials | HttpClient.HttpClient>;
export interface ListCredentialSetCredentialsRequest {
    credentialSetId: string;
    /** Path param: Identifier. */
    accountId: string;
    page?: number;
    perPage?: number;
}
export declare const ListCredentialSetCredentialsRequest: Schema.Schema<ListCredentialSetCredentialsRequest>;
export interface ListCredentialSetCredentialsResponse {
    result: {
        id: string;
        credentialSetId: string;
        location: "header" | "cookie" | (string & {});
        locationName: string;
        name: string;
    }[];
    resultInfo?: {
        count?: number | null;
        page?: number | null;
        perPage?: number | null;
        totalCount?: number | null;
    } | null;
}
export declare const ListCredentialSetCredentialsResponse: Schema.Schema<ListCredentialSetCredentialsResponse>;
export type ListCredentialSetCredentialsError = DefaultErrors;
export declare const listCredentialSetCredentials: API.PaginatedOperationMethod<ListCredentialSetCredentialsRequest, ListCredentialSetCredentialsResponse, ListCredentialSetCredentialsError, Credentials | HttpClient.HttpClient>;
export interface CreateCredentialSetCredentialRequest {
    credentialSetId: string;
    /** Path param: Identifier. */
    accountId: string;
    /** Body param: Where the credential is attached in outgoing requests. */
    location: "header" | "cookie" | (string & {});
    /** Body param: Name of the header or cookie where the credential is attached. */
    locationName: string;
    /** Body param: Human-readable name. */
    name: string;
    /** Body param: The credential value (e.g. API key, session token). Write-only. Never returned in responses. */
    value: string;
}
export declare const CreateCredentialSetCredentialRequest: Schema.Schema<CreateCredentialSetCredentialRequest>;
export interface CreateCredentialSetCredentialResponse {
    /** Credential identifier. */
    id: string;
    /** Parent credential set identifier. */
    credentialSetId: string;
    /** Where the credential is attached in outgoing requests. */
    location: "header" | "cookie" | (string & {});
    /** Name of the header or cookie where the credential is attached. */
    locationName: string;
    /** Human-readable name. */
    name: string;
}
export declare const CreateCredentialSetCredentialResponse: Schema.Schema<CreateCredentialSetCredentialResponse>;
export type CreateCredentialSetCredentialError = DefaultErrors;
export declare const createCredentialSetCredential: API.OperationMethod<CreateCredentialSetCredentialRequest, CreateCredentialSetCredentialResponse, CreateCredentialSetCredentialError, Credentials | HttpClient.HttpClient>;
export interface UpdateCredentialSetCredentialRequest {
    credentialSetId: string;
    credentialId: string;
    /** Path param: Identifier. */
    accountId: string;
    /** Body param: Where the credential is attached in outgoing requests. */
    location: "header" | "cookie" | (string & {});
    /** Body param: Name of the header or cookie where the credential is attached. */
    locationName: string;
    /** Body param: Human-readable name. */
    name: string;
    /** Body param: The credential value. Write-only. Never returned in responses. */
    value: string;
}
export declare const UpdateCredentialSetCredentialRequest: Schema.Schema<UpdateCredentialSetCredentialRequest>;
export interface UpdateCredentialSetCredentialResponse {
    /** Credential identifier. */
    id: string;
    /** Parent credential set identifier. */
    credentialSetId: string;
    /** Where the credential is attached in outgoing requests. */
    location: "header" | "cookie" | (string & {});
    /** Name of the header or cookie where the credential is attached. */
    locationName: string;
    /** Human-readable name. */
    name: string;
}
export declare const UpdateCredentialSetCredentialResponse: Schema.Schema<UpdateCredentialSetCredentialResponse>;
export type UpdateCredentialSetCredentialError = DefaultErrors;
export declare const updateCredentialSetCredential: API.OperationMethod<UpdateCredentialSetCredentialRequest, UpdateCredentialSetCredentialResponse, UpdateCredentialSetCredentialError, Credentials | HttpClient.HttpClient>;
export interface PatchCredentialSetCredentialRequest {
    credentialSetId: string;
    credentialId: string;
    /** Path param: Identifier. */
    accountId: string;
    /** Body param: Where the credential is attached in outgoing requests. */
    location?: "header" | "cookie" | (string & {});
    /** Body param: Name of the header or cookie where the credential is attached. */
    locationName?: string;
    /** Body param: Human-readable name. */
    name?: string;
    /** Body param: The credential value. Write-only. Never returned in responses. */
    value?: string;
}
export declare const PatchCredentialSetCredentialRequest: Schema.Schema<PatchCredentialSetCredentialRequest>;
export interface PatchCredentialSetCredentialResponse {
    /** Credential identifier. */
    id: string;
    /** Parent credential set identifier. */
    credentialSetId: string;
    /** Where the credential is attached in outgoing requests. */
    location: "header" | "cookie" | (string & {});
    /** Name of the header or cookie where the credential is attached. */
    locationName: string;
    /** Human-readable name. */
    name: string;
}
export declare const PatchCredentialSetCredentialResponse: Schema.Schema<PatchCredentialSetCredentialResponse>;
export type PatchCredentialSetCredentialError = DefaultErrors;
export declare const patchCredentialSetCredential: API.OperationMethod<PatchCredentialSetCredentialRequest, PatchCredentialSetCredentialResponse, PatchCredentialSetCredentialError, Credentials | HttpClient.HttpClient>;
export interface DeleteCredentialSetCredentialRequest {
    credentialSetId: string;
    credentialId: string;
    /** Identifier. */
    accountId: string;
}
export declare const DeleteCredentialSetCredentialRequest: Schema.Schema<DeleteCredentialSetCredentialRequest>;
export type DeleteCredentialSetCredentialResponse = unknown;
export declare const DeleteCredentialSetCredentialResponse: Schema.Schema<DeleteCredentialSetCredentialResponse>;
export type DeleteCredentialSetCredentialError = DefaultErrors;
export declare const deleteCredentialSetCredential: API.OperationMethod<DeleteCredentialSetCredentialRequest, DeleteCredentialSetCredentialResponse, DeleteCredentialSetCredentialError, Credentials | HttpClient.HttpClient>;
export interface GetScanRequest {
    scanId: string;
    /** Identifier. */
    accountId: string;
}
export declare const GetScanRequest: Schema.Schema<GetScanRequest>;
export interface GetScanResponse {
    /** Scan identifier. */
    id: string;
    /** The type of vulnerability scan. */
    scanType: "bola";
    /** Current lifecycle status of the scan. */
    status: "created" | "scheduled" | "planning" | "running" | "finished" | "failed" | (string & {});
    /** The target environment this scan runs against. */
    targetEnvironmentId: string;
    /** Vulnerability report produced after the scan completes. The shape depends on the scan type. Present only for finished scans. */
    report?: {
        report: {
            summary: {
                verdict: "ok" | "warning" | "inconclusive" | (string & {});
            };
            tests: {
                steps: {
                    assertions: {
                        description: string;
                        kind: {
                            parameters: {
                                max: unknown;
                                min: unknown;
                            };
                            type: "http_status_within_range";
                        };
                        observed: number | null;
                        outcome: "ok" | "fail" | "inconclusive" | (string & {});
                    }[];
                    errors?: {
                        description: string;
                        errorCode?: number | null;
                    }[] | null;
                    request?: {
                        credentialSet: {
                            id: string;
                            role: unknown | (string & {});
                        };
                        headerNames: string[];
                        method: "GET" | "DELETE" | "PATCH" | "POST" | "PUT" | (string & {});
                        url: string;
                        variableCaptures: {
                            jsonPath: unknown;
                            name: unknown;
                        }[];
                        body?: unknown | null;
                    } | null;
                    response?: {
                        body: {
                            kind: unknown;
                        } | {
                            contents: unknown;
                            kind: unknown;
                            truncated: unknown;
                        };
                        headerNames: string[];
                        status: number;
                        statusText?: string | null;
                    } | null;
                }[];
                verdict: "ok" | "warning" | "inconclusive" | (string & {});
                preflightErrors?: {
                    description: string;
                    errorCode?: number | null;
                }[] | null;
            }[];
        };
        reportSchemaVersion: "v1";
    } | null;
}
export declare const GetScanResponse: Schema.Schema<GetScanResponse>;
export type GetScanError = DefaultErrors;
export declare const getScan: API.OperationMethod<GetScanRequest, GetScanResponse, GetScanError, Credentials | HttpClient.HttpClient>;
export interface ListScansRequest {
    /** Path param: Identifier. */
    accountId: string;
    page?: number;
    perPage?: number;
}
export declare const ListScansRequest: Schema.Schema<ListScansRequest>;
export interface ListScansResponse {
    result: {
        id: string;
        scanType: "bola";
        status: "created" | "scheduled" | "planning" | "running" | "finished" | "failed" | (string & {});
        targetEnvironmentId: string;
        report?: {
            report: {
                summary: {
                    verdict: "ok" | "warning" | "inconclusive" | (string & {});
                };
                tests: {
                    steps: {
                        assertions: {
                            description: unknown;
                            kind: unknown;
                            observed: unknown;
                            outcome: unknown;
                        }[];
                        errors?: {
                            description: unknown;
                            errorCode?: unknown;
                        }[] | null;
                        request?: {
                            credentialSet: unknown;
                            headerNames: unknown;
                            method: unknown;
                            url: unknown;
                            variableCaptures: unknown;
                            body?: unknown | null;
                        } | null;
                        response?: {
                            body: unknown;
                            headerNames: unknown;
                            status: unknown;
                            statusText?: unknown;
                        } | null;
                    }[];
                    verdict: "ok" | "warning" | "inconclusive" | (string & {});
                    preflightErrors?: {
                        description: string;
                        errorCode?: number | null;
                    }[] | null;
                }[];
            };
            reportSchemaVersion: "v1";
        } | null;
    }[];
    resultInfo?: {
        count?: number | null;
        page?: number | null;
        perPage?: number | null;
        totalCount?: number | null;
    } | null;
}
export declare const ListScansResponse: Schema.Schema<ListScansResponse>;
export type ListScansError = DefaultErrors;
export declare const listScans: API.PaginatedOperationMethod<ListScansRequest, ListScansResponse, ListScansError, Credentials | HttpClient.HttpClient>;
export interface CreateScanRequest {
    /** Path param: Identifier. */
    accountId: string;
    /** Body param: Credential set references for a BOLA scan. The scanner uses the `owner` credentials for legitimate requests and the `attacker` credentials to attempt unauthorized access. */
    credentialSets: {
        attacker: string;
        owner: string;
    };
    /** Body param: OpenAPI schema definition for the API under test. The scanner uses this to discover endpoints and construct requests. */
    openApi: string;
    /** Body param */
    scanType: "bola";
    /** Body param: The target environment to scan. */
    targetEnvironmentId: string;
}
export declare const CreateScanRequest: Schema.Schema<CreateScanRequest>;
export interface CreateScanResponse {
    /** Scan identifier. */
    id: string;
    /** The type of vulnerability scan. */
    scanType: "bola";
    /** Current lifecycle status of the scan. */
    status: "created" | "scheduled" | "planning" | "running" | "finished" | "failed" | (string & {});
    /** The target environment this scan runs against. */
    targetEnvironmentId: string;
    /** Vulnerability report produced after the scan completes. The shape depends on the scan type. Present only for finished scans. */
    report?: {
        report: {
            summary: {
                verdict: "ok" | "warning" | "inconclusive" | (string & {});
            };
            tests: {
                steps: {
                    assertions: {
                        description: string;
                        kind: {
                            parameters: {
                                max: unknown;
                                min: unknown;
                            };
                            type: "http_status_within_range";
                        };
                        observed: number | null;
                        outcome: "ok" | "fail" | "inconclusive" | (string & {});
                    }[];
                    errors?: {
                        description: string;
                        errorCode?: number | null;
                    }[] | null;
                    request?: {
                        credentialSet: {
                            id: string;
                            role: unknown | (string & {});
                        };
                        headerNames: string[];
                        method: "GET" | "DELETE" | "PATCH" | "POST" | "PUT" | (string & {});
                        url: string;
                        variableCaptures: {
                            jsonPath: unknown;
                            name: unknown;
                        }[];
                        body?: unknown | null;
                    } | null;
                    response?: {
                        body: {
                            kind: unknown;
                        } | {
                            contents: unknown;
                            kind: unknown;
                            truncated: unknown;
                        };
                        headerNames: string[];
                        status: number;
                        statusText?: string | null;
                    } | null;
                }[];
                verdict: "ok" | "warning" | "inconclusive" | (string & {});
                preflightErrors?: {
                    description: string;
                    errorCode?: number | null;
                }[] | null;
            }[];
        };
        reportSchemaVersion: "v1";
    } | null;
}
export declare const CreateScanResponse: Schema.Schema<CreateScanResponse>;
export type CreateScanError = DefaultErrors;
export declare const createScan: API.OperationMethod<CreateScanRequest, CreateScanResponse, CreateScanError, Credentials | HttpClient.HttpClient>;
export interface GetTargetEnvironmentRequest {
    targetEnvironmentId: string;
    /** Identifier. */
    accountId: string;
}
export declare const GetTargetEnvironmentRequest: Schema.Schema<GetTargetEnvironmentRequest>;
export interface GetTargetEnvironmentResponse {
    /** Target environment identifier. */
    id: string;
    /** Human-readable name. */
    name: string;
    /** Identifies the Cloudflare asset to scan. Uses a `type` discriminator. Currently the service supports only `zone` targets. */
    target: {
        type: "zone";
        zoneTag: string;
    };
    /** Optional description providing additional context. */
    description?: string | null;
}
export declare const GetTargetEnvironmentResponse: Schema.Schema<GetTargetEnvironmentResponse>;
export type GetTargetEnvironmentError = DefaultErrors;
export declare const getTargetEnvironment: API.OperationMethod<GetTargetEnvironmentRequest, GetTargetEnvironmentResponse, GetTargetEnvironmentError, Credentials | HttpClient.HttpClient>;
export interface ListTargetEnvironmentsRequest {
    /** Path param: Identifier. */
    accountId: string;
    page?: number;
    perPage?: number;
}
export declare const ListTargetEnvironmentsRequest: Schema.Schema<ListTargetEnvironmentsRequest>;
export interface ListTargetEnvironmentsResponse {
    result: {
        id: string;
        name: string;
        target: {
            type: "zone";
            zoneTag: string;
        };
        description?: string | null;
    }[];
    resultInfo?: {
        count?: number | null;
        page?: number | null;
        perPage?: number | null;
        totalCount?: number | null;
    } | null;
}
export declare const ListTargetEnvironmentsResponse: Schema.Schema<ListTargetEnvironmentsResponse>;
export type ListTargetEnvironmentsError = DefaultErrors;
export declare const listTargetEnvironments: API.PaginatedOperationMethod<ListTargetEnvironmentsRequest, ListTargetEnvironmentsResponse, ListTargetEnvironmentsError, Credentials | HttpClient.HttpClient>;
export interface CreateTargetEnvironmentRequest {
    /** Path param: Identifier. */
    accountId: string;
    /** Body param: Human-readable name. */
    name: string;
    /** Body param: Identifies the Cloudflare asset to scan. Uses a `type` discriminator. Currently the service supports only `zone` targets. */
    target: {
        type: "zone";
        zoneTag: string;
    };
    /** Body param: Optional description. */
    description?: string | null;
}
export declare const CreateTargetEnvironmentRequest: Schema.Schema<CreateTargetEnvironmentRequest>;
export interface CreateTargetEnvironmentResponse {
    /** Target environment identifier. */
    id: string;
    /** Human-readable name. */
    name: string;
    /** Identifies the Cloudflare asset to scan. Uses a `type` discriminator. Currently the service supports only `zone` targets. */
    target: {
        type: "zone";
        zoneTag: string;
    };
    /** Optional description providing additional context. */
    description?: string | null;
}
export declare const CreateTargetEnvironmentResponse: Schema.Schema<CreateTargetEnvironmentResponse>;
export type CreateTargetEnvironmentError = DefaultErrors;
export declare const createTargetEnvironment: API.OperationMethod<CreateTargetEnvironmentRequest, CreateTargetEnvironmentResponse, CreateTargetEnvironmentError, Credentials | HttpClient.HttpClient>;
export interface UpdateTargetEnvironmentRequest {
    targetEnvironmentId: string;
    /** Path param: Identifier. */
    accountId: string;
    /** Body param: Human-readable name. */
    name: string;
    /** Body param: Identifies the Cloudflare asset to scan. Uses a `type` discriminator. Currently the service supports only `zone` targets. */
    target: {
        type: "zone";
        zoneTag: string;
    };
    /** Body param: Optional description. */
    description?: string | null;
}
export declare const UpdateTargetEnvironmentRequest: Schema.Schema<UpdateTargetEnvironmentRequest>;
export interface UpdateTargetEnvironmentResponse {
    /** Target environment identifier. */
    id: string;
    /** Human-readable name. */
    name: string;
    /** Identifies the Cloudflare asset to scan. Uses a `type` discriminator. Currently the service supports only `zone` targets. */
    target: {
        type: "zone";
        zoneTag: string;
    };
    /** Optional description providing additional context. */
    description?: string | null;
}
export declare const UpdateTargetEnvironmentResponse: Schema.Schema<UpdateTargetEnvironmentResponse>;
export type UpdateTargetEnvironmentError = DefaultErrors;
export declare const updateTargetEnvironment: API.OperationMethod<UpdateTargetEnvironmentRequest, UpdateTargetEnvironmentResponse, UpdateTargetEnvironmentError, Credentials | HttpClient.HttpClient>;
export interface PatchTargetEnvironmentRequest {
    targetEnvironmentId: string;
    /** Path param: Identifier. */
    accountId: string;
    /** Body param: Optional description. Omit to leave unchanged, set to `null` to clear, or provide a string to update. */
    description?: string | null;
    /** Body param: Human-readable name. */
    name?: string;
    /** Body param: Identifies the Cloudflare asset to scan. Uses a `type` discriminator. Currently the service supports only `zone` targets. */
    target?: {
        type: "zone";
        zoneTag: string;
    };
}
export declare const PatchTargetEnvironmentRequest: Schema.Schema<PatchTargetEnvironmentRequest>;
export interface PatchTargetEnvironmentResponse {
    /** Target environment identifier. */
    id: string;
    /** Human-readable name. */
    name: string;
    /** Identifies the Cloudflare asset to scan. Uses a `type` discriminator. Currently the service supports only `zone` targets. */
    target: {
        type: "zone";
        zoneTag: string;
    };
    /** Optional description providing additional context. */
    description?: string | null;
}
export declare const PatchTargetEnvironmentResponse: Schema.Schema<PatchTargetEnvironmentResponse>;
export type PatchTargetEnvironmentError = DefaultErrors;
export declare const patchTargetEnvironment: API.OperationMethod<PatchTargetEnvironmentRequest, PatchTargetEnvironmentResponse, PatchTargetEnvironmentError, Credentials | HttpClient.HttpClient>;
export interface DeleteTargetEnvironmentRequest {
    targetEnvironmentId: string;
    /** Identifier. */
    accountId: string;
}
export declare const DeleteTargetEnvironmentRequest: Schema.Schema<DeleteTargetEnvironmentRequest>;
export type DeleteTargetEnvironmentResponse = unknown;
export declare const DeleteTargetEnvironmentResponse: Schema.Schema<DeleteTargetEnvironmentResponse>;
export type DeleteTargetEnvironmentError = DefaultErrors;
export declare const deleteTargetEnvironment: API.OperationMethod<DeleteTargetEnvironmentRequest, DeleteTargetEnvironmentResponse, DeleteTargetEnvironmentError, Credentials | HttpClient.HttpClient>;
//# sourceMappingURL=vulnerability-scanner.d.ts.map