@aws-sdk/client-continuum 0.0.0-stage → 3.1157.0

package/dist-types/models/enums.d.ts

@@ -0,0 +1,1003 @@
+/**
+ * @public
+ * @enum
+ */
+export declare const ArtifactHttpMethod: {
+    readonly DELETE: "DELETE";
+    readonly GET: "GET";
+    readonly HEAD: "HEAD";
+    readonly OPTIONS: "OPTIONS";
+    readonly PATCH: "PATCH";
+    readonly POST: "POST";
+    readonly PUT: "PUT";
+};
+/**
+ * @public
+ */
+export type ArtifactHttpMethod = (typeof ArtifactHttpMethod)[keyof typeof ArtifactHttpMethod];
+/**
+ * @public
+ * @enum
+ */
+export declare const EnvironmentStatus: {
+    /**
+     * The environment is fully operational and Continuum is actively scanning.
+     */
+    readonly ACTIVE: "ACTIVE";
+};
+/**
+ * @public
+ */
+export type EnvironmentStatus = (typeof EnvironmentStatus)[keyof typeof EnvironmentStatus];
+/**
+ * @public
+ * @enum
+ */
+export declare const PatchCreationPolicy: {
+    readonly DISABLED: "DISABLED";
+    readonly ENABLED: "ENABLED";
+};
+/**
+ * @public
+ */
+export type PatchCreationPolicy = (typeof PatchCreationPolicy)[keyof typeof PatchCreationPolicy];
+/**
+ * @public
+ * @enum
+ */
+export declare const ScanFailureStage: {
+    /**
+     * The build itself failed, so no trustworthy source exists to analyze.
+     */
+    readonly BUILDING: "BUILDING";
+    /**
+     * Analysis of the built source failed.
+     */
+    readonly SCANNING: "SCANNING";
+    /**
+     * The scan's build was never accepted for execution.
+     */
+    readonly SUBMITTED: "SUBMITTED";
+    /**
+     * Failed while the build was waiting for capacity.
+     */
+    readonly WAITING_FOR_BUILD: "WAITING_FOR_BUILD";
+    /**
+     * The build succeeded, but the scan's execution inputs could not be
+     * prepared from it.
+     */
+    readonly WAITING_FOR_SCAN: "WAITING_FOR_SCAN";
+};
+/**
+ * @public
+ */
+export type ScanFailureStage = (typeof ScanFailureStage)[keyof typeof ScanFailureStage];
+/**
+ * @public
+ * @enum
+ */
+export declare const ScanOrigin: {
+    /**
+     * A customer explicitly requested the scan.
+     */
+    readonly MANUAL: "MANUAL";
+    /**
+     * Continuum created the scan from a schedule or during environment bootstrap.
+     */
+    readonly SCHEDULED: "SCHEDULED";
+};
+/**
+ * @public
+ */
+export type ScanOrigin = (typeof ScanOrigin)[keyof typeof ScanOrigin];
+/**
+ * @public
+ * @enum
+ */
+export declare const ScanStatus: {
+    /**
+     * The scan's build is running.
+     */
+    readonly BUILDING: "BUILDING";
+    /**
+     * The scan completed unsuccessfully. `failureStage` reports the phase it
+     * failed in.
+     */
+    readonly FAILED: "FAILED";
+    /**
+     * Continuum is analyzing the built source.
+     */
+    readonly SCANNING: "SCANNING";
+    /**
+     * Continuum accepted the scan request. Its build has not started yet.
+     */
+    readonly SUBMITTED: "SUBMITTED";
+    /**
+     * The scan completed successfully.
+     */
+    readonly SUCCEEDED: "SUCCEEDED";
+    /**
+     * The scan's build is waiting for capacity to run.
+     */
+    readonly WAITING_FOR_BUILD: "WAITING_FOR_BUILD";
+    /**
+     * The build finished and the scan is waiting for capacity to analyze it.
+     */
+    readonly WAITING_FOR_SCAN: "WAITING_FOR_SCAN";
+};
+/**
+ * @public
+ */
+export type ScanStatus = (typeof ScanStatus)[keyof typeof ScanStatus];
+/**
+ * @public
+ * @enum
+ */
+export declare const FindingStatus: {
+    /**
+     * The finding has been confirmed as real and actionable.
+     */
+    readonly CONFIRMED: "CONFIRMED";
+    /**
+     * The finding is not actionable (false positive, not applicable, or customer-discarded).
+     */
+    readonly DISCARDED: "DISCARDED";
+    /**
+     * The finding has been submitted and is queued for processing.
+     */
+    readonly SUBMITTED: "SUBMITTED";
+    /**
+     * Continuum is actively checking exploitability.
+     */
+    readonly VALIDATING: "VALIDATING";
+};
+/**
+ * @public
+ */
+export type FindingStatus = (typeof FindingStatus)[keyof typeof FindingStatus];
+/**
+ * @public
+ * @enum
+ */
+export declare const FindingDiscardReason: {
+    /**
+     * The weakness is real, but an existing control in the environment makes
+     * it non-actionable in practice.
+     */
+    readonly COMPENSATING_CONTROL_PRESENT: "COMPENSATING_CONTROL_PRESENT";
+    /**
+     * The finding matches an issue that was already reviewed and closed.
+     * `duplicateOfIssueId` names that issue.
+     */
+    readonly DUPLICATE_OF_CLOSED_ISSUE: "DUPLICATE_OF_CLOSED_ISSUE";
+    /**
+     * The finding describes the same problem as an already-open issue and was
+     * folded into it. `duplicateOfIssueId` names that issue.
+     */
+    readonly DUPLICATE_OF_OPEN_ISSUE: "DUPLICATE_OF_OPEN_ISSUE";
+    /**
+     * After deeper analysis against the environment's context, Continuum
+     * concluded the finding is not a real, exploitable issue here.
+     */
+    readonly FALSE_POSITIVE_VALIDATED_AGAINST_CONTEXT: "FALSE_POSITIVE_VALIDATED_AGAINST_CONTEXT";
+    /**
+     * Continuum could not confidently judge the finding; a re-scan is
+     * recommended.
+     */
+    readonly INSUFFICIENT_EVIDENCE: "INSUFFICIENT_EVIDENCE";
+    /**
+     * Real, but not in the assets Continuum is responsible for.
+     */
+    readonly OUT_OF_SCOPE: "OUT_OF_SCOPE";
+    /**
+     * Continuum could not complete processing for this finding.
+     */
+    readonly PROCESSING_FAILED: "PROCESSING_FAILED";
+    /**
+     * The validator could not reach a confident verdict at ingestion, so the
+     * finding was set aside rather than escalated.
+     */
+    readonly SCANNER_NEEDS_REVIEW: "SCANNER_NEEDS_REVIEW";
+    /**
+     * Continuum's validator determined at ingestion that the reported
+     * behavior is not actually present.
+     */
+    readonly SCANNER_VALIDATED_FALSE_POSITIVE: "SCANNER_VALIDATED_FALSE_POSITIVE";
+    /**
+     * The finding's file path does not belong to any repository in the
+     * environment's latest successful build, so Continuum cannot tie it to
+     * source code. Configure the repository as an environment source, then
+     * submit the finding again.
+     */
+    readonly SOURCE_REPO_NOT_FOUND: "SOURCE_REPO_NOT_FOUND";
+};
+/**
+ * @public
+ */
+export type FindingDiscardReason = (typeof FindingDiscardReason)[keyof typeof FindingDiscardReason];
+/**
+ * @public
+ * @enum
+ */
+export declare const FindingOcsfClass: {
+    /**
+     * OCSF class_uid 2007. Findings of this class populate `posture`.
+     */
+    readonly APPLICATION_SECURITY_POSTURE_FINDING: "APPLICATION_SECURITY_POSTURE_FINDING";
+    /**
+     * OCSF class_uid 2002.
+     */
+    readonly VULNERABILITY_FINDING: "VULNERABILITY_FINDING";
+};
+/**
+ * @public
+ */
+export type FindingOcsfClass = (typeof FindingOcsfClass)[keyof typeof FindingOcsfClass];
+/**
+ * @public
+ * @enum
+ */
+export declare const FindingSeverityId: {
+    readonly CRITICAL: "CRITICAL";
+    readonly FATAL: "FATAL";
+    readonly HIGH: "HIGH";
+    readonly INFORMATIONAL: "INFORMATIONAL";
+    readonly LOW: "LOW";
+    readonly MEDIUM: "MEDIUM";
+    readonly OTHER: "OTHER";
+    readonly UNKNOWN: "UNKNOWN";
+};
+/**
+ * @public
+ */
+export type FindingSeverityId = (typeof FindingSeverityId)[keyof typeof FindingSeverityId];
+/**
+ * @public
+ * @enum
+ */
+export declare const FindingType: {
+    /**
+     * Continuum's own scanner found a source-code vulnerability.
+     */
+    readonly CONTINUUM_CODE_VULN: "CONTINUUM_CODE_VULN";
+    /**
+     * A customer or customer integration supplied the finding as an OCSF
+     * document (class_uid 2002 or 2007), normalized into Continuum's shape at
+     * ingestion. Continuum retains the verbatim document.
+     */
+    readonly CUSTOMER_CODE_VULN: "CUSTOMER_CODE_VULN";
+};
+/**
+ * @public
+ */
+export type FindingType = (typeof FindingType)[keyof typeof FindingType];
+/**
+ * @public
+ * @enum
+ */
+export declare const FindingBlockingReason: {
+    /**
+     * In an excluded location (test code, dead code).
+     */
+    readonly EXCLUDED: "EXCLUDED";
+    /**
+     * The vulnerability category is wrong.
+     */
+    readonly MISCLASSIFIED: "MISCLASSIFIED";
+    /**
+     * No blocking reason.
+     */
+    readonly NONE: "NONE";
+    /**
+     * Exploitation is not feasible.
+     */
+    readonly NOT_FEASIBLE: "NOT_FEASIBLE";
+    /**
+     * A mitigating control is already in place.
+     */
+    readonly PROTECTED: "PROTECTED";
+    /**
+     * Real, but compensating controls cap the risk. Accompanies
+     * BENIGN_TRUE_POSITIVE.
+     */
+    readonly RISK_MITIGATED: "RISK_MITIGATED";
+    /**
+     * The code path is not reachable.
+     */
+    readonly UNREACHABLE: "UNREACHABLE";
+};
+/**
+ * @public
+ */
+export type FindingBlockingReason = (typeof FindingBlockingReason)[keyof typeof FindingBlockingReason];
+/**
+ * @public
+ * @enum
+ */
+export declare const FindingSeverityAdjustment: {
+    readonly CRITICAL: "CRITICAL";
+    readonly HIGH: "HIGH";
+    readonly INFORMATIONAL: "INFORMATIONAL";
+    readonly LOW: "LOW";
+    readonly MEDIUM: "MEDIUM";
+    readonly UNCHANGED: "UNCHANGED";
+};
+/**
+ * @public
+ */
+export type FindingSeverityAdjustment = (typeof FindingSeverityAdjustment)[keyof typeof FindingSeverityAdjustment];
+/**
+ * @public
+ * @enum
+ */
+export declare const FindingVerdict: {
+    /**
+     * Real, but compensating controls cap the risk.
+     */
+    readonly BENIGN_TRUE_POSITIVE: "BENIGN_TRUE_POSITIVE";
+    /**
+     * Not real -- the reported behavior is not present.
+     */
+    readonly FALSE_POSITIVE: "FALSE_POSITIVE";
+    /**
+     * The validator could not reach a confident verdict.
+     */
+    readonly NEEDS_REVIEW: "NEEDS_REVIEW";
+    /**
+     * Real and actionable.
+     */
+    readonly TRUE_POSITIVE: "TRUE_POSITIVE";
+};
+/**
+ * @public
+ */
+export type FindingVerdict = (typeof FindingVerdict)[keyof typeof FindingVerdict];
+/**
+ * @public
+ * @enum
+ */
+export declare const IssueEvidenceAvailability: {
+    readonly AVAILABLE: "AVAILABLE";
+    readonly NONE: "NONE";
+};
+/**
+ * @public
+ */
+export type IssueEvidenceAvailability = (typeof IssueEvidenceAvailability)[keyof typeof IssueEvidenceAvailability];
+/**
+ * @public
+ * @enum
+ */
+export declare const DeliveryReason: {
+    readonly ARTIFACT_READ_FAILED: "ARTIFACT_READ_FAILED";
+    readonly ARTIFACT_SOURCE_MISMATCH: "ARTIFACT_SOURCE_MISMATCH";
+    readonly ARTIFACT_SOURCE_MISSING: "ARTIFACT_SOURCE_MISSING";
+    readonly BUILD_NOT_FOUND: "BUILD_NOT_FOUND";
+    readonly BUILD_READ_FAILED: "BUILD_READ_FAILED";
+    readonly BUILD_RESULT_SCOPE_MISMATCH: "BUILD_RESULT_SCOPE_MISMATCH";
+    readonly DELIVERY_NOT_CONFIGURED: "DELIVERY_NOT_CONFIGURED";
+    readonly DELIVERY_SOURCE_KIND_CHANGED: "DELIVERY_SOURCE_KIND_CHANGED";
+    readonly DUPLICATE_LOGICAL_REPOSITORY: "DUPLICATE_LOGICAL_REPOSITORY";
+    readonly DUPLICATE_OR_INVALID_REPOSITORY: "DUPLICATE_OR_INVALID_REPOSITORY";
+    readonly ENVIRONMENT_DELETED: "ENVIRONMENT_DELETED";
+    readonly ENVIRONMENT_NOT_ACTIVE: "ENVIRONMENT_NOT_ACTIVE";
+    readonly ENVIRONMENT_NOT_FOUND: "ENVIRONMENT_NOT_FOUND";
+    readonly ENVIRONMENT_READ_FAILED: "ENVIRONMENT_READ_FAILED";
+    readonly EXPORT_CREDENTIALS_MISSING: "EXPORT_CREDENTIALS_MISSING";
+    readonly EXPORT_CREDENTIAL_EXPIRY_INVALID: "EXPORT_CREDENTIAL_EXPIRY_INVALID";
+    readonly EXPORT_DESTINATION_INVALID: "EXPORT_DESTINATION_INVALID";
+    readonly EXPORT_EXISTING_OBJECT_MISMATCH: "EXPORT_EXISTING_OBJECT_MISMATCH";
+    readonly EXPORT_PUT_FAILED: "EXPORT_PUT_FAILED";
+    readonly EXPORT_RECONCILIATION_READ_FAILED: "EXPORT_RECONCILIATION_READ_FAILED";
+    readonly EXPORT_ROLE_ASSUMPTION_FAILED: "EXPORT_ROLE_ASSUMPTION_FAILED";
+    readonly GITHUB_ACCESS_DENIED: "GITHUB_ACCESS_DENIED";
+    /**
+     * The pinned Build commit or one of its trees is no longer readable.
+     */
+    readonly GITHUB_BASE_NOT_FOUND: "GITHUB_BASE_NOT_FOUND";
+    /**
+     * The deterministic delivery branch or its pull request names different content.
+     */
+    readonly GITHUB_BRANCH_CONFLICT: "GITHUB_BRANCH_CONFLICT";
+    readonly GITHUB_DESTINATION_NOT_ENABLED: "github_destination_not_enabled";
+    readonly GITHUB_NOT_FOUND: "GITHUB_NOT_FOUND";
+    readonly GITHUB_RATE_LIMITED: "GITHUB_RATE_LIMITED";
+    readonly GITHUB_REPOSITORY_CHANGED: "GITHUB_REPOSITORY_CHANGED";
+    readonly GITHUB_REPOSITORY_NOT_FOUND: "GITHUB_REPOSITORY_NOT_FOUND";
+    readonly GITHUB_REQUEST_FAILED: "GITHUB_REQUEST_FAILED";
+    readonly GITHUB_REQUEST_REJECTED: "GITHUB_REQUEST_REJECTED";
+    readonly GITHUB_RESPONSE_INVALID: "GITHUB_RESPONSE_INVALID";
+    /**
+     * The GREEN attempt that staged the patch ended without PatchDelivered, or a later attempt superseded it.
+     */
+    readonly GREEN_ATTEMPT_NOT_SUCCESSFUL: "GREEN_ATTEMPT_NOT_SUCCESSFUL";
+    /**
+     * The staging GREEN attempt never completed within the delivery wait bound.
+     */
+    readonly GREEN_COMPLETION_NOT_OBSERVED: "GREEN_COMPLETION_NOT_OBSERVED";
+    readonly INCOMPLETE_SOURCE_REFERENCE: "INCOMPLETE_SOURCE_REFERENCE";
+    readonly INVALID_ARCHIVE_DIGEST: "INVALID_ARCHIVE_DIGEST";
+    readonly INVALID_ARTIFACT_SOURCE: "INVALID_ARTIFACT_SOURCE";
+    readonly INVALID_COMPLETED_MANIFEST: "INVALID_COMPLETED_MANIFEST";
+    readonly INVALID_EXPORT_RECEIPT: "INVALID_EXPORT_RECEIPT";
+    readonly INVALID_GITHUB_PROVENANCE: "INVALID_GITHUB_PROVENANCE";
+    readonly INVALID_S3_DESTINATION: "INVALID_S3_DESTINATION";
+    readonly INVALID_SERVICE_RECEIPT: "INVALID_SERVICE_RECEIPT";
+    readonly INVALID_SOURCE_INVENTORY: "INVALID_SOURCE_INVENTORY";
+    readonly INVALID_SOURCE_MANIFEST: "INVALID_SOURCE_MANIFEST";
+    readonly INVALID_SOURCE_REFERENCE: "INVALID_SOURCE_REFERENCE";
+    readonly ISSUE_INTEGRITY_FAILURE: "ISSUE_INTEGRITY_FAILURE";
+    readonly ISSUE_NOT_FOUND: "ISSUE_NOT_FOUND";
+    readonly MANIFEST_INVENTORY_MISMATCH: "MANIFEST_INVENTORY_MISMATCH";
+    readonly MANIFEST_PROVENANCE_CHANGED: "MANIFEST_PROVENANCE_CHANGED";
+    readonly MANIFEST_REPOSITORY_SET_MISMATCH: "MANIFEST_REPOSITORY_SET_MISMATCH";
+    readonly MANIFEST_SCOPE_OR_VERSION_MISMATCH: "MANIFEST_SCOPE_OR_VERSION_MISMATCH";
+    readonly MISSING_BUILD_RESULT: "MISSING_BUILD_RESULT";
+    readonly MISSING_COMPLETED_MANIFEST: "MISSING_COMPLETED_MANIFEST";
+    readonly MISSING_RESULT_DIGEST: "MISSING_RESULT_DIGEST";
+    readonly MISSING_SOURCE_MANIFEST: "MISSING_SOURCE_MANIFEST";
+    readonly MISSING_SOURCE_TARGET: "MISSING_SOURCE_TARGET";
+    readonly PATCH_CREATION_POLICY_DISABLED: "patch_creation_policy_disabled";
+    /**
+     * A hunk does not match the exact pinned file bytes it was generated against.
+     */
+    readonly PATCH_NOT_APPLICABLE: "PATCH_NOT_APPLICABLE";
+    /**
+     * The GREEN attempt completed with PATCH_STAGED and did not select this patch.
+     */
+    readonly PATCH_NOT_SELECTED: "PATCH_NOT_SELECTED";
+    readonly PATCH_STORAGE_IDENTITY_MISSING: "PATCH_STORAGE_IDENTITY_MISSING";
+    /**
+     * Rename, mode change, binary content, workflow file or unsafe path.
+     */
+    readonly PATCH_UNSUPPORTED: "PATCH_UNSUPPORTED";
+    readonly PUBLICATION_OUTCOME_UNKNOWN_AFTER_RETRY_LIMIT: "PUBLICATION_OUTCOME_UNKNOWN_AFTER_RETRY_LIMIT";
+    readonly PUBLISHER_DEADLINE_EXCEEDED: "PUBLISHER_DEADLINE_EXCEEDED";
+    readonly RESULT_COMPLETED_MANIFEST_MISMATCH: "RESULT_COMPLETED_MANIFEST_MISMATCH";
+    readonly RESULT_SOURCE_BINDING_MISMATCH: "RESULT_SOURCE_BINDING_MISMATCH";
+    readonly S3_ACCESS_DENIED: "S3_ACCESS_DENIED";
+    readonly S3_SOURCE_PREFIX_OVERLAP: "S3_SOURCE_PREFIX_OVERLAP";
+    readonly SERVICE_COPY_DIGEST_MISMATCH: "SERVICE_COPY_DIGEST_MISMATCH";
+    readonly SERVICE_OBJECT_READ_FAILED: "SERVICE_OBJECT_READ_FAILED";
+    readonly SERVICE_OBJECT_TOO_LARGE: "SERVICE_OBJECT_TOO_LARGE";
+    readonly SERVICE_RECEIPT_OUTSIDE_ISSUE: "SERVICE_RECEIPT_OUTSIDE_ISSUE";
+    readonly SOURCE_INTEGRATION_CHANGED: "SOURCE_INTEGRATION_CHANGED";
+    readonly SOURCE_INTEGRATION_INVALID: "SOURCE_INTEGRATION_INVALID";
+    readonly SOURCE_INTEGRATION_READ_FAILED: "SOURCE_INTEGRATION_READ_FAILED";
+    readonly SOURCE_INTEGRATION_UNRESOLVED: "SOURCE_INTEGRATION_UNRESOLVED";
+    readonly SOURCE_OBJECT_DIGEST_MISMATCH: "SOURCE_OBJECT_DIGEST_MISMATCH";
+    readonly SOURCE_REFERENCE_OUTSIDE_BUILD: "SOURCE_REFERENCE_OUTSIDE_BUILD";
+    readonly SOURCE_TARGET_BUILD_MISMATCH: "SOURCE_TARGET_BUILD_MISMATCH";
+    readonly UNKNOWN_REPOSITORY: "UNKNOWN_REPOSITORY";
+    readonly UNKNOWN_SOURCE_PROVIDER: "UNKNOWN_SOURCE_PROVIDER";
+    readonly UNSUPPORTED_ENVIRONMENT_SCHEMA: "UNSUPPORTED_ENVIRONMENT_SCHEMA";
+};
+/**
+ * @public
+ */
+export type DeliveryReason = (typeof DeliveryReason)[keyof typeof DeliveryReason];
+/**
+ * @public
+ * @enum
+ */
+export declare const IssuePatchDeliveryStatus: {
+    readonly FAILED: "FAILED";
+    readonly PENDING: "PENDING";
+    readonly SKIPPED: "SKIPPED";
+    readonly SUCCEEDED: "SUCCEEDED";
+};
+/**
+ * @public
+ */
+export type IssuePatchDeliveryStatus = (typeof IssuePatchDeliveryStatus)[keyof typeof IssuePatchDeliveryStatus];
+/**
+ * @public
+ * @enum
+ */
+export declare const IssuePhase: {
+    /**
+     * Continuum is assigning the issue's severity.
+     */
+    readonly PRIORITIZATION: "PRIORITIZATION";
+    /**
+     * Continuum is preparing a fix for the issue.
+     */
+    readonly REMEDIATION: "REMEDIATION";
+    /**
+     * Continuum is confirming the issue is real and exploitable.
+     */
+    readonly VALIDATION: "VALIDATION";
+};
+/**
+ * @public
+ */
+export type IssuePhase = (typeof IssuePhase)[keyof typeof IssuePhase];
+/**
+ * @public
+ * @enum
+ */
+export declare const IssueSeverity: {
+    readonly CRITICAL: "CRITICAL";
+    readonly HIGH: "HIGH";
+    readonly LOW: "LOW";
+    readonly MEDIUM: "MEDIUM";
+};
+/**
+ * @public
+ */
+export type IssueSeverity = (typeof IssueSeverity)[keyof typeof IssueSeverity];
+/**
+ * @public
+ * @enum
+ */
+export declare const IssueStatus: {
+    /**
+     * Continuum finished its workflow for the issue.
+     */
+    readonly COMPLETED: "COMPLETED";
+    /**
+     * Accepted; Continuum has not started working on the issue yet.
+     */
+    readonly CREATED: "CREATED";
+    /**
+     * Continuum stopped working on the issue without finishing. `statusReason`
+     * and `statusMessage` explain why; `phase`, when present, names the part of
+     * the workflow that failed.
+     */
+    readonly FAILED: "FAILED";
+    /**
+     * Continuum is working on the issue. `phase` names the current part of the
+     * workflow.
+     */
+    readonly IN_PROGRESS: "IN_PROGRESS";
+};
+/**
+ * @public
+ */
+export type IssueStatus = (typeof IssueStatus)[keyof typeof IssueStatus];
+/**
+ * @public
+ * @enum
+ */
+export declare const IssueStatusReason: {
+    /**
+     * Continuum hit an internal error it could not recover from.
+     */
+    readonly INTERNAL_ERROR: "INTERNAL_ERROR";
+    /**
+     * Continuum could not produce a fix for the issue.
+     */
+    readonly REMEDIATION_FAILED: "REMEDIATION_FAILED";
+};
+/**
+ * @public
+ */
+export type IssueStatusReason = (typeof IssueStatusReason)[keyof typeof IssueStatusReason];
+/**
+ * @public
+ * @enum
+ */
+export declare const IssueArtifactType: {
+    readonly AGENT_COMMUNICATION: "AGENT_COMMUNICATION";
+    readonly DECISION: "DECISION";
+    readonly EVIDENCE: "EVIDENCE";
+    readonly PATCH: "PATCH";
+    readonly REMEDIATION_PROPOSAL: "REMEDIATION_PROPOSAL";
+    readonly VALIDATION_EVIDENCE: "VALIDATION_EVIDENCE";
+};
+/**
+ * @public
+ */
+export type IssueArtifactType = (typeof IssueArtifactType)[keyof typeof IssueArtifactType];
+/**
+ * @public
+ * @enum
+ */
+export declare const DeliveryStatus: {
+    /**
+     * Retry budget exhausted after a retryable failure; no automatic retry remains.
+     */
+    readonly ABANDONED: "ABANDONED";
+    readonly FAILED: "FAILED";
+    readonly PENDING: "PENDING";
+    readonly SKIPPED: "SKIPPED";
+    readonly SUCCEEDED: "SUCCEEDED";
+};
+/**
+ * @public
+ */
+export type DeliveryStatus = (typeof DeliveryStatus)[keyof typeof DeliveryStatus];
+/**
+ * @public
+ * @enum
+ */
+export declare const PatchFormat: {
+    /**
+     * A git diff carrying binary deltas. Applied with `git apply`.
+     */
+    readonly GIT_BINARY_DIFF: "GIT_BINARY_DIFF";
+    /**
+     * A text git diff, as produced by `git diff`, with no mailbox header and
+     * no binary deltas. Applied with `git apply`.
+     */
+    readonly GIT_DIFF: "GIT_DIFF";
+    /**
+     * A git mailbox patch, as produced by `git format-patch`. Applied with
+     * `git am`.
+     */
+    readonly GIT_MAILBOX_PATCH: "GIT_MAILBOX_PATCH";
+};
+/**
+ * @public
+ */
+export type PatchFormat = (typeof PatchFormat)[keyof typeof PatchFormat];
+/**
+ * @public
+ * @enum
+ */
+export declare const SignalBand: {
+    readonly HIGH: "HIGH";
+    readonly LOW: "LOW";
+    readonly MODERATE: "MODERATE";
+    readonly VERY_LOW: "VERY_LOW";
+};
+/**
+ * @public
+ */
+export type SignalBand = (typeof SignalBand)[keyof typeof SignalBand];
+/**
+ * @public
+ * @enum
+ */
+export declare const SignalDimension: {
+    readonly BLAST_RADIUS: "BLAST_RADIUS";
+    readonly CODE_CONTEXT: "CODE_CONTEXT";
+    readonly EXPLOITABILITY: "EXPLOITABILITY";
+    readonly IMPACT_ASSESSMENT: "IMPACT_ASSESSMENT";
+    readonly LIKELIHOOD_ASSESSMENT: "LIKELIHOOD_ASSESSMENT";
+    readonly NETWORK_EXPOSURE: "NETWORK_EXPOSURE";
+    readonly PRECONDITION: "PRECONDITION";
+};
+/**
+ * @public
+ */
+export type SignalDimension = (typeof SignalDimension)[keyof typeof SignalDimension];
+/**
+ * @public
+ * @enum
+ */
+export declare const ValidationConfidenceTier: {
+    /**
+     * Proven against a build of the customer's code.
+     */
+    readonly BUILD_PROVEN: "BUILD_PROVEN";
+    /**
+     * Proven against a running target. The strongest tier.
+     */
+    readonly RUNTIME_PROVEN: "RUNTIME_PROVEN";
+    /**
+     * Concluded from reading source only; nothing was executed.
+     */
+    readonly SOURCE_READ: "SOURCE_READ";
+    /**
+     * Proven by static analysis.
+     */
+    readonly STATIC_PROVEN: "STATIC_PROVEN";
+};
+/**
+ * @public
+ */
+export type ValidationConfidenceTier = (typeof ValidationConfidenceTier)[keyof typeof ValidationConfidenceTier];
+/**
+ * @public
+ * @enum
+ */
+export declare const ExploitabilityVerdict: {
+    readonly EXPLOITABLE: "EXPLOITABLE";
+    readonly NOT_EXPLOITABLE: "NOT_EXPLOITABLE";
+    readonly UNCERTAIN: "UNCERTAIN";
+};
+/**
+ * @public
+ */
+export type ExploitabilityVerdict = (typeof ExploitabilityVerdict)[keyof typeof ExploitabilityVerdict];
+/**
+ * @public
+ * @enum
+ */
+export declare const SignalBasis: {
+    /**
+     * Read directly from the customer's source code.
+     */
+    readonly CODE: "CODE";
+    /**
+     * Stated explicitly by the originating finding.
+     */
+    readonly FINDING: "FINDING";
+    /**
+     * Stated by a claim or node attribute in the environment's context graph.
+     */
+    readonly GRAPH: "GRAPH";
+    /**
+     * Reasoned from indirect evidence, such as context clues, several sources
+     * read together, or known behavior of the framework involved. No single
+     * source states the value, but the producer had grounds for it.
+     */
+    readonly INFERRED: "INFERRED";
+    /**
+     * No evidence either way, so the producer used a default value. The
+     * weakest basis: read the value as a default, not as something established
+     * about the customer's system, and check it first.
+     */
+    readonly NO_EVIDENCE_DEFAULT: "NO_EVIDENCE_DEFAULT";
+};
+/**
+ * @public
+ */
+export type SignalBasis = (typeof SignalBasis)[keyof typeof SignalBasis];
+/**
+ * @public
+ * @enum
+ */
+export declare const SignalAttackerGains: {
+    /**
+     * Arbitrary code execution.
+     */
+    readonly EXECUTE: "EXECUTE";
+    /**
+     * Modification with no security consequence.
+     */
+    readonly MODIFY_COSMETIC: "MODIFY_COSMETIC";
+    /**
+     * Modification of business data.
+     */
+    readonly MODIFY_DATA: "MODIFY_DATA";
+    /**
+     * Modification of data that governs privilege.
+     */
+    readonly MODIFY_PRIVILEGED: "MODIFY_PRIVILEGED";
+    /**
+     * Neither read nor modification.
+     */
+    readonly NEITHER: "NEITHER";
+    /**
+     * Read access only.
+     */
+    readonly READ: "READ";
+};
+/**
+ * @public
+ */
+export type SignalAttackerGains = (typeof SignalAttackerGains)[keyof typeof SignalAttackerGains];
+/**
+ * @public
+ * @enum
+ */
+export declare const SignalBlastRadius: {
+    /**
+     * Beyond this tenant.
+     */
+    readonly CROSS_TENANT: "CROSS_TENANT";
+    /**
+     * Other users within this tenant.
+     */
+    readonly OTHER_USERS_IN_TENANT: "OTHER_USERS_IN_TENANT";
+    /**
+     * Only the attacker's own scope.
+     */
+    readonly OWN_SCOPE: "OWN_SCOPE";
+};
+/**
+ * @public
+ */
+export type SignalBlastRadius = (typeof SignalBlastRadius)[keyof typeof SignalBlastRadius];
+/**
+ * @public
+ * @enum
+ */
+export declare const SignalTargetValue: {
+    readonly HIGH: "HIGH";
+    readonly LOW: "LOW";
+    readonly MEDIUM: "MEDIUM";
+};
+/**
+ * @public
+ */
+export type SignalTargetValue = (typeof SignalTargetValue)[keyof typeof SignalTargetValue];
+/**
+ * @public
+ * @enum
+ */
+export declare const SignalAccessLevel: {
+    /**
+     * Any ordinary organisational credential.
+     */
+    readonly ANY_AUTHENTICATED: "ANY_AUTHENTICATED";
+    /**
+     * No authentication: an unauthenticated entry point.
+     */
+    readonly NONE: "NONE";
+    /**
+     * A privileged credential.
+     */
+    readonly PRIVILEGED: "PRIVILEGED";
+};
+/**
+ * @public
+ */
+export type SignalAccessLevel = (typeof SignalAccessLevel)[keyof typeof SignalAccessLevel];
+/**
+ * @public
+ * @enum
+ */
+export declare const SignalStrength: {
+    readonly MODERATE: "MODERATE";
+    readonly NONE: "NONE";
+    readonly STRONG: "STRONG";
+    readonly WEAK: "WEAK";
+};
+/**
+ * @public
+ */
+export type SignalStrength = (typeof SignalStrength)[keyof typeof SignalStrength];
+/**
+ * @public
+ * @enum
+ */
+export declare const ExploitEffect: {
+    readonly BEHAVIOR_CHANGED: "BEHAVIOR_CHANGED";
+    readonly DATA_LEAKED: "DATA_LEAKED";
+    readonly ERROR_REVEALED: "ERROR_REVEALED";
+    readonly NO_EFFECT: "NO_EFFECT";
+};
+/**
+ * @public
+ */
+export type ExploitEffect = (typeof ExploitEffect)[keyof typeof ExploitEffect];
+/**
+ * @public
+ * @enum
+ */
+export declare const FlowVerdictValue: {
+    readonly CONFIRMED: "CONFIRMED";
+    readonly DENIED: "DENIED";
+    readonly INCONCLUSIVE: "INCONCLUSIVE";
+};
+/**
+ * @public
+ */
+export type FlowVerdictValue = (typeof FlowVerdictValue)[keyof typeof FlowVerdictValue];
+/**
+ * @public
+ * @enum
+ */
+export declare const ValidationTerminalStatus: {
+    /**
+     * The run finished and assessed every layer it attempted.
+     */
+    readonly COMPLETED: "COMPLETED";
+    /**
+     * The run did not finish.
+     */
+    readonly FAILED: "FAILED";
+    /**
+     * The run finished without testing anything, because the environment
+     * exposed no source substrate to assess. Distinct from `COMPLETED`: a
+     * reader has to be able to tell "assessed and concluded" from "had nothing
+     * to assess", and this is the single most common outcome in practice.
+     */
+    readonly NO_SOURCE_AVAILABLE: "NO_SOURCE_AVAILABLE";
+    /**
+     * The run finished but assessed only some of what it set out to. The
+     * evidence present is sound; it is not the whole intended assessment.
+     */
+    readonly PARTIAL: "PARTIAL";
+};
+/**
+ * @public
+ */
+export type ValidationTerminalStatus = (typeof ValidationTerminalStatus)[keyof typeof ValidationTerminalStatus];
+/**
+ * @public
+ * @enum
+ */
+export declare const CollectorType: {
+    /**
+     * Collect AWS resource configuration.
+     */
+    readonly AWS_COLLECTOR: "AWS_COLLECTOR";
+};
+/**
+ * @public
+ */
+export type CollectorType = (typeof CollectorType)[keyof typeof CollectorType];
+/**
+ * @public
+ * @enum
+ */
+export declare const CollectorStatus: {
+    /**
+     * The Collector is available for reads, updates, and associations.
+     */
+    readonly ACTIVE: "ACTIVE";
+    /**
+     * Deletion has started. New Collectors for the same account and Region
+     * remain blocked until cleanup completes and the record is removed.
+     */
+    readonly PENDING_DELETION: "PENDING_DELETION";
+};
+/**
+ * @public
+ */
+export type CollectorStatus = (typeof CollectorStatus)[keyof typeof CollectorStatus];
+/**
+ * @public
+ * @enum
+ */
+export declare const GitLabTargetType: {
+    readonly GROUP: "GROUP";
+    readonly PROJECT: "PROJECT";
+};
+/**
+ * @public
+ */
+export type GitLabTargetType = (typeof GitLabTargetType)[keyof typeof GitLabTargetType];
+/**
+ * @public
+ * @enum
+ */
+export declare const IntegrationType: {
+    readonly GITHUB: "GITHUB";
+    readonly GITLAB: "GITLAB";
+    readonly S3: "S3";
+};
+/**
+ * @public
+ */
+export type IntegrationType = (typeof IntegrationType)[keyof typeof IntegrationType];
+/**
+ * @public
+ * @enum
+ */
+export declare const GitLabTokenRotation: {
+    /**
+     * Continuum rotates the token before it expires.
+     */
+    readonly AUTOMATIC: "AUTOMATIC";
+    /**
+     * The token is not rotated and stops working at its expiry.
+     */
+    readonly NONE: "NONE";
+};
+/**
+ * @public
+ */
+export type GitLabTokenRotation = (typeof GitLabTokenRotation)[keyof typeof GitLabTokenRotation];
+/**
+ * @public
+ * @enum
+ */
+export declare const IntegrationAuthorizationProviderType: {
+    /**
+     * GitHub.com. The authorization code is exchanged by a GitHub CreateIntegration.
+     */
+    readonly GITHUB: "GITHUB";
+};
+/**
+ * @public
+ */
+export type IntegrationAuthorizationProviderType = (typeof IntegrationAuthorizationProviderType)[keyof typeof IntegrationAuthorizationProviderType];
+/**
+ * @public
+ * @enum
+ */
+export declare const OAuthCodeChallengeMethod: {
+    /**
+     * The challenge is BASE64URL(SHA256(code verifier)), without padding.
+     */
+    readonly S256: "S256";
+};
+/**
+ * @public
+ */
+export type OAuthCodeChallengeMethod = (typeof OAuthCodeChallengeMethod)[keyof typeof OAuthCodeChallengeMethod];