import { NonNullablePaths } from '@wix/sdk-types';

/**
 * A site-scoped accessibility scan.
 *
 * Running a scan creates this asynchronous resource. Poll it while it is
 * QUEUED or RUNNING. Read findings only after it reaches COMPLETED or
 * PARTIALLY_COMPLETED; when it reaches FAILED, inspect failure and start a new
 * scan after correcting the cause.
 * The Wix site is always derived from the authenticated caller context.
 * Published sites use their published version; unpublished sites use their
 * latest saved version.
 */
interface AccessibilityScan {
    /**
     * Server-generated scan ID.
     * @format GUID
     * @readonly
     */
    _id?: string;
    /**
     * What this scan checks. Immutable after the scan is created.
     * @immutable
     */
    target?: AccessibilityScanTarget;
    /**
     * Current asynchronous lifecycle state.
     * @readonly
     */
    status?: AccessibilityScanStatusWithLiterals;
    /**
     * Page-processing progress. Updated throughout the scan and retained when
     * the scan reaches a terminal state.
     * @readonly
     */
    progress?: AccessibilityScanProgress;
    /**
     * Aggregate results. Populated for completed and partially completed scans.
     * @readonly
     */
    summary?: AccessibilityScanSummary;
    /**
     * Public, sanitized failure details. Populated only when status is FAILED.
     * @readonly
     */
    failure?: AccessibilityScanFailure;
    /**
     * Date and time the scan was queued.
     * @readonly
     */
    _createdDate?: Date | null;
    /**
     * Date and time processing started.
     * @readonly
     */
    startedDate?: Date | null;
    /**
     * Date and time the scan reached a terminal state.
     * @readonly
     */
    completedDate?: Date | null;
    /**
     * Date and time the stored scan results expire.
     * @readonly
     */
    resultsExpirationDate?: Date | null;
    /**
     * Date and time this resource last changed.
     * @readonly
     */
    _updatedDate?: Date | null;
    /**
     * Revision number used for optimistic concurrency.
     * @readonly
     */
    revision?: string;
}
/**
 * Selects exactly one scan target on the authenticated Wix site: the full
 * site, one page, or every page in a supported Wix page collection.
 */
interface AccessibilityScanTarget extends AccessibilityScanTargetTargetOneOf {
    /** Multi-page scope to scan. Currently supports the complete site. */
    scope?: AccessibilityScanScopeWithLiterals;
    /** One page to scan. */
    page?: PageScanTarget;
    /** Every page in one supported Wix page collection. */
    pageCollection?: PageCollectionScanTarget;
    /**
     * Discriminator for the target variant. It must match the populated target
     * field.
     */
    targetType?: TargetTypeWithLiterals;
}
/** @oneof */
interface AccessibilityScanTargetTargetOneOf {
    /** Multi-page scope to scan. Currently supports the complete site. */
    scope?: AccessibilityScanScopeWithLiterals;
    /** One page to scan. */
    page?: PageScanTarget;
    /** Every page in one supported Wix page collection. */
    pageCollection?: PageCollectionScanTarget;
}
declare enum TargetType {
    SCOPE = "SCOPE",
    PAGE = "PAGE",
    PAGE_COLLECTION = "PAGE_COLLECTION"
}
/** @enumType */
type TargetTypeWithLiterals = TargetType | 'SCOPE' | 'PAGE' | 'PAGE_COLLECTION';
declare enum AccessibilityScanScope {
    /** Checks every supported page and site-level rule on the site. */
    ACCESSIBILITY_SCAN_SCOPE_FULL_SITE = "ACCESSIBILITY_SCAN_SCOPE_FULL_SITE"
}
/** @enumType */
type AccessibilityScanScopeWithLiterals = AccessibilityScanScope | 'ACCESSIBILITY_SCAN_SCOPE_FULL_SITE';
/**
 * Identifies one static, template, or generated page by Wix page ID or by a
 * URL belonging to the selected Wix site. Exactly one identifier must be
 * provided.
 */
interface PageScanTarget extends PageScanTargetIdentifierOneOf {
    /**
     * Wix page ID when it uniquely identifies the page to scan. Use `pageUrl`
     * for a generated page such as a specific product or blog post.
     * @minLength 1
     * @maxLength 100
     */
    pageId?: string;
    /**
     * Absolute page URL belonging to the selected Wix site.
     * @format WEB_URL
     * @minLength 1
     * @maxLength 2048
     */
    pageUrl?: string;
}
/** @oneof */
interface PageScanTargetIdentifierOneOf {
    /**
     * Wix page ID when it uniquely identifies the page to scan. Use `pageUrl`
     * for a generated page such as a specific product or blog post.
     * @minLength 1
     * @maxLength 100
     */
    pageId?: string;
    /**
     * Absolute page URL belonging to the selected Wix site.
     * @format WEB_URL
     * @minLength 1
     * @maxLength 2048
     */
    pageUrl?: string;
}
/**
 * Identifies a supported collection of generated pages, such as all product,
 * blog post, booking service, or event pages. Supported collection IDs are
 * documented by this API and remain stable even if internal item types change.
 */
interface PageCollectionScanTarget {
    /**
     * Stable public collection ID, for example "wix.stores.products".
     * @minLength 1
     * @maxLength 200
     */
    collectionId?: string;
}
/** Asynchronous scan lifecycle. */
declare enum AccessibilityScanStatus {
    /** Accepted and waiting for capacity. */
    ACCESSIBILITY_SCAN_STATUS_QUEUED = "ACCESSIBILITY_SCAN_STATUS_QUEUED",
    /** Actively checking the selected site or page. */
    ACCESSIBILITY_SCAN_STATUS_RUNNING = "ACCESSIBILITY_SCAN_STATUS_RUNNING",
    /** Finished successfully. Findings are available. */
    ACCESSIBILITY_SCAN_STATUS_COMPLETED = "ACCESSIBILITY_SCAN_STATUS_COMPLETED",
    /**
     * Finished with one or more pages that could not be checked. Available
     * findings and the failed-page count are still returned.
     */
    ACCESSIBILITY_SCAN_STATUS_PARTIALLY_COMPLETED = "ACCESSIBILITY_SCAN_STATUS_PARTIALLY_COMPLETED",
    /** No usable result was produced. */
    ACCESSIBILITY_SCAN_STATUS_FAILED = "ACCESSIBILITY_SCAN_STATUS_FAILED"
}
/** @enumType */
type AccessibilityScanStatusWithLiterals = AccessibilityScanStatus | 'ACCESSIBILITY_SCAN_STATUS_QUEUED' | 'ACCESSIBILITY_SCAN_STATUS_RUNNING' | 'ACCESSIBILITY_SCAN_STATUS_COMPLETED' | 'ACCESSIBILITY_SCAN_STATUS_PARTIALLY_COMPLETED' | 'ACCESSIBILITY_SCAN_STATUS_FAILED';
/** Page-processing progress for a scan. */
interface AccessibilityScanProgress {
    /**
     * Pages discovered for this scan. At every point in the scan, this equals
     * `processedPageCount + failedPageCount + pendingPageCount`.
     * @readonly
     */
    discoveredPageCount?: number;
    /**
     * Pages processed successfully.
     * @readonly
     */
    processedPageCount?: number;
    /**
     * Pages that could not be processed.
     * @readonly
     */
    failedPageCount?: number;
    /**
     * Discovered pages that are queued or currently being processed. Zero in a
     * terminal scan.
     * @readonly
     */
    pendingPageCount?: number;
}
/** Aggregate, user-facing scan results. */
interface AccessibilityScanSummary {
    /**
     * Total actionable findings, including page-scoped and site-level findings.
     * In a terminal scan, this equals `siteLevelFindingCount` plus the finding
     * counts from all page summaries.
     * @readonly
     */
    findingCount?: number;
    /**
     * Pages checked successfully. In a terminal scan, this equals
     * `progress.processedPageCount`.
     * @readonly
     */
    scannedPageCount?: number;
    /**
     * Successfully scanned pages containing at least one finding.
     * @readonly
     */
    affectedPageCount?: number;
    /**
     * Findings grouped by severity.
     * @maxSize 5
     * @readonly
     */
    findingsBySeverity?: AccessibilitySeverityCount[];
    /**
     * Findings grouped into stable user-intent categories. One finding can
     * contribute to more than one category, so counts may overlap.
     * @maxSize 20
     * @readonly
     */
    findingsByCategory?: AccessibilityFindingCategoryCount[];
    /**
     * What the scan actually evaluated, including checks with no findings.
     * @readonly
     */
    coverage?: AccessibilityScanCoverage;
    /**
     * Findings that apply to the site rather than to one specific page.
     * @readonly
     */
    siteLevelFindingCount?: number;
}
/** Number of findings for one severity. */
interface AccessibilitySeverityCount {
    /**
     * Severity represented by this count.
     * @readonly
     */
    severity?: AccessibilitySeverityWithLiterals;
    /**
     * Number of findings.
     * @readonly
     */
    count?: number;
}
/** Public severity levels, aligned with axe-core impact levels. */
declare enum AccessibilitySeverity {
    ACCESSIBILITY_SEVERITY_CRITICAL = "ACCESSIBILITY_SEVERITY_CRITICAL",
    ACCESSIBILITY_SEVERITY_SERIOUS = "ACCESSIBILITY_SEVERITY_SERIOUS",
    ACCESSIBILITY_SEVERITY_MODERATE = "ACCESSIBILITY_SEVERITY_MODERATE",
    ACCESSIBILITY_SEVERITY_MINOR = "ACCESSIBILITY_SEVERITY_MINOR",
    ACCESSIBILITY_SEVERITY_INFO = "ACCESSIBILITY_SEVERITY_INFO"
}
/** @enumType */
type AccessibilitySeverityWithLiterals = AccessibilitySeverity | 'ACCESSIBILITY_SEVERITY_CRITICAL' | 'ACCESSIBILITY_SEVERITY_SERIOUS' | 'ACCESSIBILITY_SEVERITY_MODERATE' | 'ACCESSIBILITY_SEVERITY_MINOR' | 'ACCESSIBILITY_SEVERITY_INFO';
/** Number of findings in one user-intent category. */
interface AccessibilityFindingCategoryCount {
    /**
     * Category represented by this count.
     * @readonly
     */
    category?: AccessibilityFindingCategoryWithLiterals;
    /**
     * Number of findings.
     * @readonly
     */
    count?: number;
}
/**
 * Stable categories for common accessibility requests. Categories let callers
 * ask for related findings without knowing every underlying rule ID.
 */
declare enum AccessibilityFindingCategory {
    ACCESSIBILITY_FINDING_CATEGORY_ALTERNATIVE_TEXT = "ACCESSIBILITY_FINDING_CATEGORY_ALTERNATIVE_TEXT",
    ACCESSIBILITY_FINDING_CATEGORY_HEADING_STRUCTURE = "ACCESSIBILITY_FINDING_CATEGORY_HEADING_STRUCTURE",
    ACCESSIBILITY_FINDING_CATEGORY_COLOR_CONTRAST = "ACCESSIBILITY_FINDING_CATEGORY_COLOR_CONTRAST",
    ACCESSIBILITY_FINDING_CATEGORY_SCREEN_READER = "ACCESSIBILITY_FINDING_CATEGORY_SCREEN_READER",
    ACCESSIBILITY_FINDING_CATEGORY_KEYBOARD = "ACCESSIBILITY_FINDING_CATEGORY_KEYBOARD",
    ACCESSIBILITY_FINDING_CATEGORY_OTHER = "ACCESSIBILITY_FINDING_CATEGORY_OTHER"
}
/** @enumType */
type AccessibilityFindingCategoryWithLiterals = AccessibilityFindingCategory | 'ACCESSIBILITY_FINDING_CATEGORY_ALTERNATIVE_TEXT' | 'ACCESSIBILITY_FINDING_CATEGORY_HEADING_STRUCTURE' | 'ACCESSIBILITY_FINDING_CATEGORY_COLOR_CONTRAST' | 'ACCESSIBILITY_FINDING_CATEGORY_SCREEN_READER' | 'ACCESSIBILITY_FINDING_CATEGORY_KEYBOARD' | 'ACCESSIBILITY_FINDING_CATEGORY_OTHER';
/**
 * Checks that were actually evaluated. Callers must use this coverage instead
 * of treating an absent finding as proof that an unsupported check passed.
 */
interface AccessibilityScanCoverage {
    /**
     * User-intent categories covered by at least one executed rule.
     * @maxSize 20
     * @readonly
     */
    checkedCategories?: AccessibilityFindingCategoryWithLiterals[];
    /**
     * Stable public rule IDs that were executed, including rules that passed.
     * @maxSize 500
     * @minLength 1
     * @maxLength 200
     * @readonly
     */
    checkedRuleIds?: string[];
}
/** Sanitized failure information for a scan or one page in a scan. */
interface AccessibilityScanFailure {
    /**
     * Stable failure category.
     * @readonly
     */
    code?: AccessibilityScanFailureCodeWithLiterals;
    /**
     * Human-readable recovery guidance. Never contains raw page content or
     * internal service details.
     * @maxLength 1000
     * @readonly
     */
    message?: string;
}
/** Public scan failure categories. */
declare enum AccessibilityScanFailureCode {
    ACCESSIBILITY_SCAN_FAILURE_CODE_SITE_UNAVAILABLE = "ACCESSIBILITY_SCAN_FAILURE_CODE_SITE_UNAVAILABLE",
    ACCESSIBILITY_SCAN_FAILURE_CODE_PAGE_NOT_FOUND = "ACCESSIBILITY_SCAN_FAILURE_CODE_PAGE_NOT_FOUND",
    ACCESSIBILITY_SCAN_FAILURE_CODE_PAGE_NOT_ACCESSIBLE = "ACCESSIBILITY_SCAN_FAILURE_CODE_PAGE_NOT_ACCESSIBLE",
    ACCESSIBILITY_SCAN_FAILURE_CODE_ANALYSIS_FAILED = "ACCESSIBILITY_SCAN_FAILURE_CODE_ANALYSIS_FAILED"
}
/** @enumType */
type AccessibilityScanFailureCodeWithLiterals = AccessibilityScanFailureCode | 'ACCESSIBILITY_SCAN_FAILURE_CODE_SITE_UNAVAILABLE' | 'ACCESSIBILITY_SCAN_FAILURE_CODE_PAGE_NOT_FOUND' | 'ACCESSIBILITY_SCAN_FAILURE_CODE_PAGE_NOT_ACCESSIBLE' | 'ACCESSIBILITY_SCAN_FAILURE_CODE_ANALYSIS_FAILED';
interface RunAccessibilityScanRequest {
    /** Full-site, page, or supported page-collection target. */
    target: AccessibilityScanTarget;
    /**
     * Caller-generated UUID used to safely retry this request. Generate a new
     * key for every intended scan and reuse it only when retrying that same
     * request.
     * @format GUID
     * @minLength 1
     * @maxLength 36
     */
    idempotencyKey: string;
}
interface RunAccessibilityScanResponse {
    /**
     * Created or deduplicated scan in its current lifecycle state. An idempotent
     * retry can return a running or terminal scan.
     */
    accessibilityScan?: AccessibilityScan;
    /**
     * Suggested delay before polling. Zero when the returned scan is terminal.
     * @max 60
     * @readonly
     */
    suggestedPollIntervalSeconds?: number;
}
/** Points to the existing scan when a new run is rejected. */
interface ExistingAccessibilityScanError {
    /**
     * Poll or read this existing scan instead of starting another one.
     * @format GUID
     * @readonly
     */
    accessibilityScanId?: string;
}
/** Returned instead of silently truncating a multi-page scan. */
interface ScanSizeLimitExceededError {
    /**
     * Number of pages detected for the requested target.
     * @min 1
     * @readonly
     */
    detectedPageCount?: number;
    /**
     * Maximum pages supported by one scan.
     * @min 1
     * @readonly
     */
    maxPageCount?: number;
}
/** Returned when the scan state cannot be confirmed. */
interface AccessibilityScanStateUnknownError {
    /**
     * Read this scan again before deciding whether to start another scan.
     * @format GUID
     * @readonly
     */
    accessibilityScanId?: string;
}
interface ListAccessibilityScanPageCollectionsRequest {
    /** Cursor paging. The server default and maximum page size is 100. */
    paging?: CursorPaging;
}
interface CursorPaging {
    /**
     * Maximum number of items to return in the results.
     * @max 100
     */
    limit?: number | null;
    /**
     * Pointer to the next or previous page in the list of results.
     *
     * Pass the relevant cursor token from the `pagingMetadata` object in the previous call's response.
     * Not relevant for the first request.
     * @maxLength 16000
     */
    cursor?: string | null;
}
interface ListAccessibilityScanPageCollectionsResponse {
    /**
     * Collections supported and currently available on the selected site.
     * @maxSize 100
     */
    pageCollections?: AccessibilityScanPageCollection[];
    /** Cursor metadata for retrieving the next page. */
    pagingMetadata?: CursorPagingMetadata;
}
/**
 * A page collection that can currently be scanned on the authenticated site.
 * Specify the returned `collectionId` when selecting a page-collection
 * target.
 */
interface AccessibilityScanPageCollection {
    /**
     * Stable public ID accepted by PageCollectionScanTarget.
     * @minLength 1
     * @maxLength 200
     * @readonly
     */
    collectionId?: string;
    /**
     * User-facing collection name, for example "Store products".
     * @minLength 1
     * @maxLength 500
     * @readonly
     */
    displayName?: string;
}
interface CursorPagingMetadata {
    /** Number of items returned in current page. */
    count?: number | null;
    /** Cursor strings that point to the next page, previous page, or both. */
    cursors?: Cursors;
    /**
     * Whether there are more pages to retrieve following the current page.
     *
     * + `true`: Another page of results can be retrieved.
     * + `false`: This is the last page.
     */
    hasNext?: boolean | null;
}
interface Cursors {
    /**
     * Cursor string pointing to the next page in the list of results.
     * @maxLength 16000
     */
    next?: string | null;
    /**
     * Cursor pointing to the previous page in the list of results.
     * @maxLength 16000
     */
    prev?: string | null;
}
interface ListAccessibilityScanPageSummariesRequest {
    /**
     * Completed or partially completed scan ID.
     * @format GUID
     * @minLength 1
     * @maxLength 36
     */
    accessibilityScanId: string;
    /** Cursor paging. The server default and maximum page size is 100. */
    paging?: CursorPaging;
}
interface ListAccessibilityScanPageSummariesResponse {
    /**
     * One aggregate result for every discovered page, including clean and failed
     * pages.
     * @maxSize 100
     */
    pageSummaries?: AccessibilityScanPageSummary[];
    /** Cursor metadata for retrieving the next page. */
    pagingMetadata?: CursorPagingMetadata;
}
/**
 * Aggregate results for one discovered page in any scan. Every discovered page
 * appears exactly once, including pages with no findings and pages that failed.
 */
interface AccessibilityScanPageSummary {
    /**
     * Page represented by this summary.
     * @readonly
     */
    page?: AccessibilityPageReference;
    /**
     * Whether the page completed or failed. A failed page has zero findings and
     * no coverage because it did not produce a usable result.
     * @readonly
     */
    status?: AccessibilityPageScanStatusWithLiterals;
    /**
     * Actionable page-scoped findings on this page.
     * @readonly
     */
    findingCount?: number;
    /**
     * Findings on this page grouped by severity.
     * @maxSize 5
     * @readonly
     */
    findingsBySeverity?: AccessibilitySeverityCount[];
    /**
     * Populated exactly when status is ACCESSIBILITY_PAGE_SCAN_STATUS_FAILED.
     * @readonly
     */
    failure?: AccessibilityScanFailure;
    /**
     * Findings on this page grouped into stable user-intent categories. One
     * finding can contribute to more than one category, so counts may overlap.
     * @maxSize 20
     * @readonly
     */
    findingsByCategory?: AccessibilityFindingCategoryCount[];
    /**
     * Checks actually evaluated on this page, including checks that passed.
     * @readonly
     */
    coverage?: AccessibilityScanCoverage;
}
/** Public page identity returned with a finding. */
interface AccessibilityPageReference {
    /**
     * Wix page ID, when available.
     * @maxLength 100
     * @readonly
     */
    pageId?: string;
    /**
     * Absolute URL of the scanned page.
     * @format WEB_URL
     * @maxLength 2048
     * @readonly
     */
    pageUrl?: string;
    /**
     * User-facing page title.
     * @maxLength 500
     * @readonly
     */
    title?: string;
    /**
     * Collection and item identity for a generated page. Omitted for static
     * pages. Implementation-specific page types are never returned.
     * @readonly
     */
    pageCollection?: AccessibilityPageCollectionReference;
}
/**
 * Stable public identity for the collection item that generated a page. Both
 * fields are populated whenever this message is returned.
 */
interface AccessibilityPageCollectionReference {
    /**
     * Stable public page-collection ID, for example "wix.stores.products".
     * @minLength 1
     * @maxLength 200
     * @readonly
     */
    collectionId?: string;
    /**
     * Public ID of the collection item. For example, this can identify the
     * product or blog post that an agent must update through the owning public
     * API.
     * @minLength 1
     * @maxLength 500
     * @readonly
     */
    itemId?: string;
}
declare enum AccessibilityPageScanStatus {
    ACCESSIBILITY_PAGE_SCAN_STATUS_COMPLETED = "ACCESSIBILITY_PAGE_SCAN_STATUS_COMPLETED",
    ACCESSIBILITY_PAGE_SCAN_STATUS_FAILED = "ACCESSIBILITY_PAGE_SCAN_STATUS_FAILED"
}
/** @enumType */
type AccessibilityPageScanStatusWithLiterals = AccessibilityPageScanStatus | 'ACCESSIBILITY_PAGE_SCAN_STATUS_COMPLETED' | 'ACCESSIBILITY_PAGE_SCAN_STATUS_FAILED';
interface GetLatestAccessibilityScanRequest {
    /** Target whose latest stored scan should be returned. */
    target: AccessibilityScanTarget;
}
interface GetLatestAccessibilityScanResponse {
    /** Latest stored scan for the requested target. */
    accessibilityScan?: AccessibilityScan;
}
interface GetAccessibilityScanRequest {
    /**
     * Scan ID returned by [Run Accessibility Scan](https://dev.wix.com/docs/api-reference/site/accessibility/accessibility-scans-v1/run-accessibility-scan).
     * @format GUID
     * @minLength 1
     * @maxLength 36
     */
    accessibilityScanId: string;
}
interface GetAccessibilityScanResponse {
    /** Current scan state and any available aggregate result. */
    accessibilityScan?: AccessibilityScan;
    /**
     * Suggested delay before polling again. Zero when the scan is in a terminal
     * state.
     * @max 60
     * @readonly
     */
    suggestedPollIntervalSeconds?: number;
}
interface ListAccessibilityScanFindingsRequest {
    /**
     * Completed or partially completed scan ID.
     * @format GUID
     * @minLength 1
     * @maxLength 36
     */
    accessibilityScanId: string;
    /** Optional supported filters. Filters are combined with AND. */
    filter?: AccessibilityFindingFilter;
    /** Cursor paging. The server default and maximum page size is 100. */
    paging?: CursorPaging;
}
interface AccessibilityFindingFilter {
    /** Limit findings to one page ID or URL. */
    page?: PageScanTarget;
    /**
     * Limit findings to one stable rule ID.
     * @maxLength 200
     */
    ruleId?: string;
    /** Limit findings to one severity. */
    severity?: AccessibilitySeverityWithLiterals;
    /**
     * Limit findings to one or more user-intent categories. Categories are
     * combined with OR and then combined with other filters using AND.
     * @maxSize 20
     */
    categories?: AccessibilityFindingCategoryWithLiterals[];
}
interface ListAccessibilityScanFindingsResponse {
    /**
     * Actionable findings matching the request.
     * @maxSize 100
     */
    findings?: AccessibilityFinding[];
    /** Cursor metadata for retrieving the next page. */
    pagingMetadata?: CursorPagingMetadata;
}
/**
 * One actionable accessibility issue found by a scan. Findings are immutable,
 * site-scoped, and available only through their parent scan.
 */
interface AccessibilityFinding {
    /**
     * Stable ID for this finding within the scan.
     * @minLength 1
     * @maxLength 512
     * @readonly
     */
    _id?: string;
    /**
     * Parent accessibility scan ID.
     * @format GUID
     * @readonly
     */
    accessibilityScanId?: string;
    /**
     * Stable accessibility rule ID, for example "image-alt".
     * @maxLength 200
     * @readonly
     */
    ruleId?: string;
    /**
     * User-facing rule title.
     * @maxLength 500
     * @readonly
     */
    title?: string;
    /**
     * Finding severity.
     * @readonly
     */
    severity?: AccessibilitySeverityWithLiterals;
    /**
     * Affected page. Omitted for site-level findings.
     * @readonly
     */
    page?: AccessibilityPageReference;
    /**
     * Affected element. Omitted when a rule is not element-specific.
     * @readonly
     */
    element?: AccessibilityElementReference;
    /**
     * What failed and why it matters.
     * @maxLength 5000
     * @readonly
     */
    description?: string;
    /**
     * Concise summary of how to address the issue. For ordered instructions,
     * use `fixGuidance`.
     * @maxLength 5000
     * @readonly
     */
    remediationSummary?: string;
    /**
     * WCAG success criteria related to this finding.
     * @maxSize 20
     * @readonly
     */
    wcagCriteria?: WcagCriterion[];
    /**
     * Public documentation for this rule, when available.
     * @format WEB_URL
     * @maxLength 2048
     * @readonly
     */
    helpUrl?: string;
    /**
     * Structured instructions for fixing and verifying this finding.
     * @readonly
     */
    fixGuidance?: AccessibilityFixGuidance;
    /**
     * User-intent categories for grouping and filtering related rules. A finding
     * can belong to multiple categories, for example alternative text and
     * screen-reader support.
     * @maxSize 20
     * @readonly
     */
    categories?: AccessibilityFindingCategoryWithLiterals[];
}
/**
 * A safe element location. Raw HTML and internal rule context are never
 * returned.
 */
interface AccessibilityElementReference {
    /**
     * Wix component ID or another stable element reference, when available.
     * @maxLength 500
     * @readonly
     */
    elementId?: string;
    /**
     * CSS selector suitable for locating the element on the scanned page.
     * @maxLength 2000
     * @readonly
     */
    selector?: string;
    /**
     * Short human-readable element description.
     * @maxLength 1000
     * @readonly
     */
    description?: string;
}
/** WCAG success criterion related to a finding. */
interface WcagCriterion {
    /**
     * Criterion number, for example "1.1.1".
     * @minLength 1
     * @maxLength 20
     * @readonly
     */
    _id?: string;
    /**
     * Conformance level for this criterion.
     * @readonly
     */
    level?: WcagLevelWithLiterals;
}
declare enum WcagLevel {
    /** Level A criterion. */
    WCAG_LEVEL_A = "WCAG_LEVEL_A",
    /** Level AA criterion. */
    WCAG_LEVEL_AA = "WCAG_LEVEL_AA",
    /**
     * Level AAA criterion. Accessibility scans don't currently evaluate Level
     * AAA criteria.
     */
    WCAG_LEVEL_AAA = "WCAG_LEVEL_AAA"
}
/** @enumType */
type WcagLevelWithLiterals = WcagLevel | 'WCAG_LEVEL_A' | 'WCAG_LEVEL_AA' | 'WCAG_LEVEL_AAA';
/**
 * Agent-friendly guidance for resolving one finding. The guidance identifies
 * the type of change, gives ordered steps, explains how to verify the result,
 * and flags decisions that require human judgment.
 */
interface AccessibilityFixGuidance {
    /**
     * Primary kind of change needed to resolve the finding.
     * @readonly
     */
    category?: AccessibilityFixCategoryWithLiterals;
    /**
     * Ordered, concrete steps for resolving the finding.
     * @maxSize 20
     * @maxLength 2000
     * @readonly
     */
    recommendedSteps?: string[];
    /**
     * Ordered checks that confirm whether the fix worked.
     * @maxSize 10
     * @maxLength 2000
     * @readonly
     */
    verificationSteps?: string[];
    /**
     * Whether the agent must ask a person for content, intent, or approval.
     * @readonly
     */
    humanInputRequired?: boolean;
    /**
     * What human decision is needed. Populated when `humanInputRequired` is
     * `true`.
     * @maxLength 2000
     * @readonly
     */
    humanInputReason?: string;
}
/** Primary type of change recommended for a finding. */
declare enum AccessibilityFixCategory {
    ACCESSIBILITY_FIX_CATEGORY_CODE = "ACCESSIBILITY_FIX_CATEGORY_CODE",
    ACCESSIBILITY_FIX_CATEGORY_CONTENT = "ACCESSIBILITY_FIX_CATEGORY_CONTENT",
    ACCESSIBILITY_FIX_CATEGORY_DESIGN = "ACCESSIBILITY_FIX_CATEGORY_DESIGN",
    ACCESSIBILITY_FIX_CATEGORY_SITE_CONFIGURATION = "ACCESSIBILITY_FIX_CATEGORY_SITE_CONFIGURATION",
    ACCESSIBILITY_FIX_CATEGORY_MANUAL_REVIEW = "ACCESSIBILITY_FIX_CATEGORY_MANUAL_REVIEW"
}
/** @enumType */
type AccessibilityFixCategoryWithLiterals = AccessibilityFixCategory | 'ACCESSIBILITY_FIX_CATEGORY_CODE' | 'ACCESSIBILITY_FIX_CATEGORY_CONTENT' | 'ACCESSIBILITY_FIX_CATEGORY_DESIGN' | 'ACCESSIBILITY_FIX_CATEGORY_SITE_CONFIGURATION' | 'ACCESSIBILITY_FIX_CATEGORY_MANUAL_REVIEW';
/** @docsIgnore */
type RunAccessibilityScanApplicationErrors = {
    code?: 'INVALID_SCAN_TARGET';
    description?: string;
    data?: Record<string, any>;
} | {
    code?: 'SCAN_ALREADY_IN_PROGRESS';
    description?: string;
    data?: ExistingAccessibilityScanError;
} | {
    code?: 'IDEMPOTENCY_KEY_REUSED';
    description?: string;
    data?: ExistingAccessibilityScanError;
} | {
    code?: 'SCAN_TARGET_NOT_AVAILABLE';
    description?: string;
    data?: Record<string, any>;
} | {
    code?: 'SCAN_SIZE_LIMIT_EXCEEDED';
    description?: string;
    data?: ScanSizeLimitExceededError;
} | {
    code?: 'SCAN_STATE_UNKNOWN';
    description?: string;
    data?: AccessibilityScanStateUnknownError;
};
/** @docsIgnore */
type ListAccessibilityScanPageSummariesApplicationErrors = {
    code?: 'ACCESSIBILITY_SCAN_NOT_FOUND';
    description?: string;
    data?: Record<string, any>;
} | {
    code?: 'SCAN_NOT_COMPLETE';
    description?: string;
    data?: Record<string, any>;
} | {
    code?: 'SCAN_RESULTS_NOT_AVAILABLE';
    description?: string;
    data?: Record<string, any>;
} | {
    code?: 'SCAN_RESULTS_EXPIRED';
    description?: string;
    data?: Record<string, any>;
};
/** @docsIgnore */
type GetLatestAccessibilityScanApplicationErrors = {
    code?: 'INVALID_SCAN_TARGET';
    description?: string;
    data?: Record<string, any>;
} | {
    code?: 'ACCESSIBILITY_SCAN_NOT_FOUND';
    description?: string;
    data?: Record<string, any>;
} | {
    code?: 'SCAN_STATE_UNKNOWN';
    description?: string;
    data?: AccessibilityScanStateUnknownError;
};
/** @docsIgnore */
type GetAccessibilityScanApplicationErrors = {
    code?: 'ACCESSIBILITY_SCAN_NOT_FOUND';
    description?: string;
    data?: Record<string, any>;
} | {
    code?: 'SCAN_STATE_UNKNOWN';
    description?: string;
    data?: AccessibilityScanStateUnknownError;
};
/** @docsIgnore */
type ListAccessibilityScanFindingsApplicationErrors = {
    code?: 'ACCESSIBILITY_SCAN_NOT_FOUND';
    description?: string;
    data?: Record<string, any>;
} | {
    code?: 'SCAN_NOT_COMPLETE';
    description?: string;
    data?: Record<string, any>;
} | {
    code?: 'SCAN_RESULTS_NOT_AVAILABLE';
    description?: string;
    data?: Record<string, any>;
} | {
    code?: 'SCAN_RESULTS_EXPIRED';
    description?: string;
    data?: Record<string, any>;
};
/**
 * Queues an asynchronous accessibility scan.
 *
 * Retrying with the same `idempotencyKey` for the same site returns the
 * original scan. Reusing the key with a different target fails.
 *
 * Fails if the target is invalid or unavailable, another scan for the same
 * target is active, the idempotency key was reused for another target, or
 * the supported scan size is exceeded. Multi-page targets are never silently
 * sampled or truncated. Run requests are limited to 5 per minute per Wix
 * site and can return HTTP 429. Retry the same intended scan with the same
 * idempotency key.
 * @param target - Full-site, page, or supported page-collection target.
 * @public
 * @documentationMaturity preview
 * @requiredField options
 * @requiredField options.idempotencyKey
 * @requiredField target
 * @permissionId accessibility:v1:accessibility_scan:run_accessibility_scan
 * @applicableIdentity APP
 * @fqn wix.accessibility.v1.AccessibilityScansService.RunAccessibilityScan
 */
declare function runAccessibilityScan(target: AccessibilityScanTarget, options: NonNullablePaths<RunAccessibilityScanOptions, `idempotencyKey`, 0>): Promise<NonNullablePaths<RunAccessibilityScanResponse, `accessibilityScan._id` | `accessibilityScan.target.scope` | `accessibilityScan.target.page.pageId` | `accessibilityScan.target.page.pageUrl` | `accessibilityScan.target.pageCollection.collectionId` | `accessibilityScan.target.targetType` | `accessibilityScan.status` | `accessibilityScan.progress.discoveredPageCount` | `accessibilityScan.progress.processedPageCount` | `accessibilityScan.progress.failedPageCount` | `accessibilityScan.progress.pendingPageCount` | `accessibilityScan.summary.findingCount` | `accessibilityScan.summary.scannedPageCount` | `accessibilityScan.summary.affectedPageCount` | `accessibilityScan.summary.findingsBySeverity` | `accessibilityScan.summary.findingsBySeverity.${number}.severity` | `accessibilityScan.summary.findingsBySeverity.${number}.count` | `accessibilityScan.summary.findingsByCategory` | `accessibilityScan.summary.findingsByCategory.${number}.category` | `accessibilityScan.summary.findingsByCategory.${number}.count` | `accessibilityScan.summary.coverage.checkedCategories` | `accessibilityScan.summary.coverage.checkedRuleIds` | `accessibilityScan.summary.siteLevelFindingCount` | `accessibilityScan.failure.code` | `accessibilityScan.failure.message` | `accessibilityScan.revision` | `suggestedPollIntervalSeconds`, 4> & {
    __applicationErrorsType?: RunAccessibilityScanApplicationErrors;
}>;
interface RunAccessibilityScanOptions {
    /**
     * Caller-generated UUID used to safely retry this request. Generate a new
     * key for every intended scan and reuse it only when retrying that same
     * request.
     * @format GUID
     * @minLength 1
     * @maxLength 36
     */
    idempotencyKey: string;
}
/**
 * Lists the supported page collections currently available on the
 * authenticated site. Use the returned collection ID unchanged when the
 * user asks to scan a page type such as all products, blog posts, booking
 * services, events, or restaurant menu pages.
 * @public
 * @documentationMaturity preview
 * @permissionId accessibility:v1:accessibility_scan:list_accessibility_scan_page_collections
 * @applicableIdentity APP
 * @fqn wix.accessibility.v1.AccessibilityScansService.ListAccessibilityScanPageCollections
 */
declare function listAccessibilityScanPageCollections(options?: ListAccessibilityScanPageCollectionsOptions): Promise<NonNullablePaths<ListAccessibilityScanPageCollectionsResponse, `pageCollections` | `pageCollections.${number}.collectionId` | `pageCollections.${number}.displayName`, 2>>;
interface ListAccessibilityScanPageCollectionsOptions {
    /** Cursor paging. The server default and maximum page size is 100. */
    paging?: CursorPaging;
}
/**
 * Lists per-page aggregate results for a completed or partially completed
 * scan. The response includes every discovered page: affected pages, pages
 * with no findings, and pages that failed to scan. A page scan returns at
 * most one page summary. Results are available only for completed and
 * partially completed scans; a failed or expired scan never returns an empty
 * list that could be mistaken for a clean result. Affected pages are returned
 * first, ordered by their highest finding severity (critical first) and then
 * finding count. Failed and clear pages follow in stable page-URL order.
 * @param accessibilityScanId - Completed or partially completed scan ID.
 * @public
 * @documentationMaturity preview
 * @requiredField accessibilityScanId
 * @permissionId accessibility:v1:accessibility_scan:list_accessibility_scan_page_summaries
 * @applicableIdentity APP
 * @fqn wix.accessibility.v1.AccessibilityScansService.ListAccessibilityScanPageSummaries
 */
declare function listAccessibilityScanPageSummaries(accessibilityScanId: string, options?: ListAccessibilityScanPageSummariesOptions): Promise<NonNullablePaths<ListAccessibilityScanPageSummariesResponse, `pageSummaries` | `pageSummaries.${number}.page.pageId` | `pageSummaries.${number}.page.pageUrl` | `pageSummaries.${number}.page.title` | `pageSummaries.${number}.page.pageCollection.collectionId` | `pageSummaries.${number}.page.pageCollection.itemId` | `pageSummaries.${number}.status` | `pageSummaries.${number}.findingCount` | `pageSummaries.${number}.failure.code` | `pageSummaries.${number}.failure.message`, 4> & {
    __applicationErrorsType?: ListAccessibilityScanPageSummariesApplicationErrors;
}>;
interface ListAccessibilityScanPageSummariesOptions {
    /** Cursor paging. The server default and maximum page size is 100. */
    paging?: CursorPaging;
}
/**
 * Retrieves the latest stored scan for the requested target without
 * starting a new scan. Fails if the target is invalid or has no stored scan.
 * @param target - Target whose latest stored scan should be returned.
 * @public
 * @documentationMaturity preview
 * @requiredField target
 * @permissionId accessibility:v1:accessibility_scan:get_latest_accessibility_scan
 * @applicableIdentity APP
 * @fqn wix.accessibility.v1.AccessibilityScansService.GetLatestAccessibilityScan
 */
declare function getLatestAccessibilityScan(target: AccessibilityScanTarget): Promise<NonNullablePaths<GetLatestAccessibilityScanResponse, `accessibilityScan._id` | `accessibilityScan.target.scope` | `accessibilityScan.target.page.pageId` | `accessibilityScan.target.page.pageUrl` | `accessibilityScan.target.pageCollection.collectionId` | `accessibilityScan.target.targetType` | `accessibilityScan.status` | `accessibilityScan.progress.discoveredPageCount` | `accessibilityScan.progress.processedPageCount` | `accessibilityScan.progress.failedPageCount` | `accessibilityScan.progress.pendingPageCount` | `accessibilityScan.summary.findingCount` | `accessibilityScan.summary.scannedPageCount` | `accessibilityScan.summary.affectedPageCount` | `accessibilityScan.summary.findingsBySeverity` | `accessibilityScan.summary.findingsBySeverity.${number}.severity` | `accessibilityScan.summary.findingsBySeverity.${number}.count` | `accessibilityScan.summary.findingsByCategory` | `accessibilityScan.summary.findingsByCategory.${number}.category` | `accessibilityScan.summary.findingsByCategory.${number}.count` | `accessibilityScan.summary.coverage.checkedCategories` | `accessibilityScan.summary.coverage.checkedRuleIds` | `accessibilityScan.summary.siteLevelFindingCount` | `accessibilityScan.failure.code` | `accessibilityScan.failure.message` | `accessibilityScan.revision`, 4> & {
    __applicationErrorsType?: GetLatestAccessibilityScanApplicationErrors;
}>;
/**
 * Retrieves a scan and its latest status.
 *
 * Poll this method until the scan reaches a terminal state. REST callers
 * wait for the positive `suggestedPollIntervalSeconds` value returned in the
 * response. SDK callers poll every 5 seconds because the generated get
 * method returns the scan entity directly. If the retained scan record
 * expired, start a new scan.
 * @param accessibilityScanId - Scan ID returned by [Run Accessibility Scan](https://dev.wix.com/docs/api-reference/site/accessibility/accessibility-scans-v1/run-accessibility-scan).
 * @public
 * @documentationMaturity preview
 * @requiredField accessibilityScanId
 * @permissionId accessibility:v1:accessibility_scan:get_accessibility_scan
 * @applicableIdentity APP
 * @returns Current scan state and any available aggregate result.
 * @fqn wix.accessibility.v1.AccessibilityScansService.GetAccessibilityScan
 */
declare function getAccessibilityScan(accessibilityScanId: string): Promise<NonNullablePaths<AccessibilityScan, `_id` | `target.scope` | `target.page.pageId` | `target.page.pageUrl` | `target.pageCollection.collectionId` | `target.targetType` | `status` | `progress.discoveredPageCount` | `progress.processedPageCount` | `progress.failedPageCount` | `progress.pendingPageCount` | `summary.findingCount` | `summary.scannedPageCount` | `summary.affectedPageCount` | `summary.findingsBySeverity` | `summary.findingsBySeverity.${number}.severity` | `summary.findingsBySeverity.${number}.count` | `summary.findingsByCategory` | `summary.findingsByCategory.${number}.category` | `summary.findingsByCategory.${number}.count` | `summary.coverage.checkedCategories` | `summary.coverage.checkedRuleIds` | `summary.siteLevelFindingCount` | `failure.code` | `failure.message` | `revision`, 3> & {
    __applicationErrorsType?: GetAccessibilityScanApplicationErrors;
}>;
/**
 * Lists actionable findings for a completed or partially completed scan.
 * Findings are cursor-paged and ordered by severity (critical, serious,
 * moderate, minor, then info), page URL, and finding ID. They may be
 * filtered by page, rule, severity, or user-intent category. Results are
 * available only for completed and partially completed scans; a failed or
 * expired scan never returns an empty list that could be mistaken for no
 * accessibility issues.
 * @param accessibilityScanId - Completed or partially completed scan ID.
 * @public
 * @documentationMaturity preview
 * @requiredField accessibilityScanId
 * @permissionId accessibility:v1:accessibility_scan:list_accessibility_scan_findings
 * @applicableIdentity APP
 * @fqn wix.accessibility.v1.AccessibilityScansService.ListAccessibilityScanFindings
 */
declare function listAccessibilityScanFindings(accessibilityScanId: string, options?: ListAccessibilityScanFindingsOptions): Promise<NonNullablePaths<ListAccessibilityScanFindingsResponse, `findings` | `findings.${number}._id` | `findings.${number}.accessibilityScanId` | `findings.${number}.ruleId` | `findings.${number}.title` | `findings.${number}.severity` | `findings.${number}.page.pageId` | `findings.${number}.page.pageUrl` | `findings.${number}.page.title` | `findings.${number}.page.pageCollection.collectionId` | `findings.${number}.page.pageCollection.itemId` | `findings.${number}.element.elementId` | `findings.${number}.element.selector` | `findings.${number}.element.description` | `findings.${number}.description` | `findings.${number}.remediationSummary` | `findings.${number}.helpUrl` | `findings.${number}.fixGuidance.category` | `findings.${number}.fixGuidance.humanInputRequired` | `findings.${number}.fixGuidance.humanInputReason`, 4> & {
    __applicationErrorsType?: ListAccessibilityScanFindingsApplicationErrors;
}>;
interface ListAccessibilityScanFindingsOptions {
    /** Optional supported filters. Filters are combined with AND. */
    filter?: AccessibilityFindingFilter;
    /** Cursor paging. The server default and maximum page size is 100. */
    paging?: CursorPaging;
}

export { type AccessibilityElementReference, type AccessibilityFinding, AccessibilityFindingCategory, type AccessibilityFindingCategoryCount, type AccessibilityFindingCategoryWithLiterals, type AccessibilityFindingFilter, AccessibilityFixCategory, type AccessibilityFixCategoryWithLiterals, type AccessibilityFixGuidance, type AccessibilityPageCollectionReference, type AccessibilityPageReference, AccessibilityPageScanStatus, type AccessibilityPageScanStatusWithLiterals, type AccessibilityScan, type AccessibilityScanCoverage, type AccessibilityScanFailure, AccessibilityScanFailureCode, type AccessibilityScanFailureCodeWithLiterals, type AccessibilityScanPageCollection, type AccessibilityScanPageSummary, type AccessibilityScanProgress, AccessibilityScanScope, type AccessibilityScanScopeWithLiterals, type AccessibilityScanStateUnknownError, AccessibilityScanStatus, type AccessibilityScanStatusWithLiterals, type AccessibilityScanSummary, type AccessibilityScanTarget, type AccessibilityScanTargetTargetOneOf, AccessibilitySeverity, type AccessibilitySeverityCount, type AccessibilitySeverityWithLiterals, type CursorPaging, type CursorPagingMetadata, type Cursors, type ExistingAccessibilityScanError, type GetAccessibilityScanApplicationErrors, type GetAccessibilityScanRequest, type GetAccessibilityScanResponse, type GetLatestAccessibilityScanApplicationErrors, type GetLatestAccessibilityScanRequest, type GetLatestAccessibilityScanResponse, type ListAccessibilityScanFindingsApplicationErrors, type ListAccessibilityScanFindingsOptions, type ListAccessibilityScanFindingsRequest, type ListAccessibilityScanFindingsResponse, type ListAccessibilityScanPageCollectionsOptions, type ListAccessibilityScanPageCollectionsRequest, type ListAccessibilityScanPageCollectionsResponse, type ListAccessibilityScanPageSummariesApplicationErrors, type ListAccessibilityScanPageSummariesOptions, type ListAccessibilityScanPageSummariesRequest, type ListAccessibilityScanPageSummariesResponse, type PageCollectionScanTarget, type PageScanTarget, type PageScanTargetIdentifierOneOf, type RunAccessibilityScanApplicationErrors, type RunAccessibilityScanOptions, type RunAccessibilityScanRequest, type RunAccessibilityScanResponse, type ScanSizeLimitExceededError, TargetType, type TargetTypeWithLiterals, type WcagCriterion, WcagLevel, type WcagLevelWithLiterals, getAccessibilityScan, getLatestAccessibilityScan, listAccessibilityScanFindings, listAccessibilityScanPageCollections, listAccessibilityScanPageSummaries, runAccessibilityScan };