@openforge/elastic-enterprise-search/lib/api/app/types.d.ts

Official Node.js client for Elastic Enterprise Search, App Search, and Workplace Search.

export interface GetAdaptiveRelevanceSettingsRequest {
    /**
     * Name of the engine
     */
    engine_name: string;
}
export interface GetAdaptiveRelevanceSettingsResponse {
    curation: {
        enabled?: boolean;
        mode?: 'manual' | 'automatic';
        timeframe?: number;
        max_size?: number;
        min_clicks?: number;
        schedule_unit?: 'second' | 'minute' | 'hour' | 'day' | 'week' | 'month';
        schedule_frequency?: number;
    };
}
export interface PutAdaptiveRelevanceSettingsRequest {
    /**
     * Name of the engine
     */
    engine_name: string;
    body?: {
        curation: {
            enabled?: boolean;
            mode?: 'manual' | 'automatic';
            timeframe?: number;
            max_size?: number;
            min_clicks?: number;
            schedule_unit?: 'second' | 'minute' | 'hour' | 'day' | 'week' | 'month';
            schedule_frequency?: number;
        };
    };
}
export interface PutAdaptiveRelevanceSettingsResponse {
    curation: {
        enabled?: boolean;
        mode?: 'manual' | 'automatic';
        timeframe?: number;
        max_size?: number;
        min_clicks?: number;
        schedule_unit?: 'second' | 'minute' | 'hour' | 'day' | 'week' | 'month';
        schedule_frequency?: number;
    };
}
export interface ListAdaptiveRelevanceSuggestionsRequest {
    /**
     * Name of the engine
     */
    engine_name: string;
    body?: {
        page?: {
            current?: number;
            size?: number;
        };
        filters?: {
            status?: Array<'pending' | 'applied' | 'automated' | 'rejected' | 'disabled'>;
            type?: 'curation';
        };
    };
}
export type ListAdaptiveRelevanceSuggestionsResponse = Record<string, unknown>;
export interface PutAdaptiveRelevanceSuggestionsRequest {
    /**
     * Name of the engine
     */
    engine_name: string;
    body?: Array<{
        query?: string;
        type?: 'curation';
        status?: 'pending' | 'applied' | 'automated' | 'rejected' | 'disabled';
    }>;
}
export interface PutAdaptiveRelevanceSuggestionsResponse {
    results?: Array<{
        query?: string;
        type?: 'curation';
        status?: 'pending' | 'applied' | 'automated' | 'rejected' | 'disabled';
        errors: string[];
    } | {
        query?: string;
        status?: 'pending' | 'applied' | 'automated' | 'rejected' | 'disabled';
        updated_at?: string;
        created_at?: string;
    }>;
}
export interface GetAdaptiveRelevanceSuggestionsRequest {
    /**
     * Name of the engine
     */
    engine_name: string;
    /**
     * Query to obtain suggestions
     */
    search_suggestion_query: string;
    body?: {
        page?: {
            current?: number;
            size?: number;
        };
        filters?: {
            status?: Array<'pending' | 'applied' | 'automated' | 'rejected' | 'disabled'>;
            type?: 'curation';
        };
    };
}
export type GetAdaptiveRelevanceSuggestionsResponse = Record<string, unknown>;
export interface RefreshAdaptiveRelevanceUpdateProcessRequest {
    /**
     * Name of the engine
     */
    engine_name: string;
    /**
     * Adaptive relevance suggestion type
     */
    adaptive_relevance_suggestion_type: 'curation';
}
export type RefreshAdaptiveRelevanceUpdateProcessResponse = Record<string, unknown>;
export interface GetTopClicksAnalyticsRequest {
    /**
     * Name of the engine
     */
    engine_name: string;
    body?: {
        query?: string;
        filters?: {
            tag: string | string[];
        } | {
            date: {
                to: string;
                from: string;
            };
        } | {
            all: Array<{
                tag: string | string[];
            } | {
                date: {
                    to: string;
                    from: string;
                };
            }>;
        };
        page?: {
            size: number;
        };
    };
}
export interface GetTopClicksAnalyticsResponse {
    meta: {
        page: {
            current?: number;
            size?: number;
        };
    };
    results: Array<{
        document_id: string;
        clicks: number;
    }>;
}
export interface GetCountAnalyticsRequest {
    /**
     * Name of the engine
     */
    engine_name: string;
    body?: {
        filters?: {
            query: string;
        } | {
            document_id: string;
        } | {
            tag: string | string[];
        } | {
            date: {
                to: string;
                from: string;
            };
        } | {
            all: Array<{
                query: string;
            } | {
                document_id: string;
            } | {
                tag: string | string[];
            } | {
                date: {
                    to: string;
                    from: string;
                };
            }>;
        };
        interval?: string;
    };
}
export interface GetCountAnalyticsResponse {
    results: Array<{
        clicks: number;
        queries: number;
        from: string;
        to: string;
    }>;
}
export interface GetTopQueriesAnalyticsRequest {
    /**
     * Name of the engine
     */
    engine_name: string;
    body?: {
        filters?: {
            clicks: boolean;
        } | {
            results: boolean;
        } | {
            tag: string | string[];
        } | {
            date: {
                to: string;
                from: string;
            };
        } | {
            all: Array<{
                clicks: boolean;
            } | {
                results: boolean;
            } | {
                tag: string | string[];
            } | {
                date: {
                    to: string;
                    from: string;
                };
            }>;
        };
        page?: {
            size: number;
        };
    };
}
export interface GetTopQueriesAnalyticsResponse {
    meta: {
        page: {
            current?: number;
            size?: number;
        };
    };
    results: Array<{
        term: string;
        clicks: number;
        queries: number;
    }>;
}
export interface LogClickthroughRequest {
    /**
     * Name of the engine
     */
    engine_name: string;
    body?: {
        query: string;
        request_id?: string;
        document_id: string;
        tags?: string[];
    };
}
export type LogClickthroughResponse = Record<string, unknown>;
export interface GetCrawlerUrlExtractionResultRequest {
    /**
     * Name of the engine
     */
    engine_name: string;
    body: string;
}
export interface GetCrawlerUrlExtractionResultResponse {
    url: string;
    normalized_url: string;
    results: {
        download: {
            status_code: number;
            redirect_location?: string;
            error?: string;
        };
        extraction: {
            content_hash: string;
            content_hash_fields: string[];
            content_fields: {};
            meta_tag_warnings: Array<{
                name: string;
                value: string;
                error: string;
                message: string;
            }>;
        };
        indexing: {
            document_id: string;
            document_fields: {};
        };
        deduplication: {
            urls_count: number;
            urls_sample: string[];
        };
    };
}
export interface CreateCrawlerCrawlRequestRequest {
    /**
     * Name of the engine
     */
    engine_name: string;
    body?: {
        overrides: {
            max_crawl_depth?: number;
            sitemap_discovery_disabled?: boolean;
            domain_allowlist?: string[];
            seed_urls?: string[];
            sitemap_urls?: string[];
        };
    };
}
export interface CreateCrawlerCrawlRequestResponse {
    id: string;
    type?: 'full' | 'partial';
    status: 'success' | 'failed' | 'canceled' | 'skipped' | 'pending' | 'suspended' | 'starting' | 'running' | 'canceling' | 'suspending';
    created_at: string;
    begun_at: string;
    completed_at: string;
}
export interface ListCrawlerCrawlRequestsRequest {
    /**
     * Name of the engine
     */
    engine_name: string;
    page?: {
        /**
         * The page to fetch. Defaults to 1
         */
        current?: number;
        /**
         * The number of results per page
         */
        size?: number;
    };
}
export interface ListCrawlerCrawlRequestsResponse {
    meta: {
        page: {
            current: number;
            total_pages: number;
            total_results: number;
            size: number;
        };
    };
    results: Array<{
        id: string;
        type?: 'full' | 'partial';
        status: 'success' | 'failed' | 'canceled' | 'skipped' | 'pending' | 'suspended' | 'starting' | 'running' | 'canceling' | 'suspending';
        created_at: string;
        begun_at: string;
        completed_at: string;
    }>;
}
export interface GetCrawlerCrawlRequestRequest {
    /**
     * Name of the engine
     */
    engine_name: string;
    /**
     * Crawl Request ID
     */
    crawl_request_id: string;
}
export type GetCrawlerCrawlRequestResponse = {
    id: string;
    type?: 'full' | 'partial';
    status: 'success' | 'failed' | 'canceled' | 'skipped' | 'pending' | 'suspended' | 'starting' | 'running' | 'canceling' | 'suspending';
    created_at: string;
    begun_at: string;
    completed_at: string;
} & {
    crawl_config?: {
        allOf?: [
            {
                type: 'object';
                properties: {
                    max_crawl_depth: {
                        type: 'integer';
                    };
                    sitemap_discovery_disabled: {
                        type: 'boolean';
                    };
                    domain_allowlist: {
                        type: 'array';
                        items: {
                            type: 'string';
                        };
                    };
                    seed_urls: {
                        type: 'array';
                        items: {
                            type: 'string';
                        };
                    };
                    sitemap_urls: {
                        type: 'array';
                        items: {
                            type: 'string';
                        };
                    };
                };
                additionalProperties: false;
            }
        ];
        crawl_rules?: Array<{}>;
        deduplication_settings?: Array<{}>;
    };
    stats: {
        [k: string]: unknown;
    } | null;
};
export interface GetCrawlerActiveCrawlRequestRequest {
    /**
     * Name of the engine
     */
    engine_name: string;
}
export type GetCrawlerActiveCrawlRequestResponse = {
    id: string;
    type?: 'full' | 'partial';
    status: 'success' | 'failed' | 'canceled' | 'skipped' | 'pending' | 'suspended' | 'starting' | 'running' | 'canceling' | 'suspending';
    created_at: string;
    begun_at: string;
    completed_at: string;
} & {
    crawl_config?: {
        allOf?: [
            {
                type: 'object';
                properties: {
                    max_crawl_depth: {
                        type: 'integer';
                    };
                    sitemap_discovery_disabled: {
                        type: 'boolean';
                    };
                    domain_allowlist: {
                        type: 'array';
                        items: {
                            type: 'string';
                        };
                    };
                    seed_urls: {
                        type: 'array';
                        items: {
                            type: 'string';
                        };
                    };
                    sitemap_urls: {
                        type: 'array';
                        items: {
                            type: 'string';
                        };
                    };
                };
                additionalProperties: false;
            }
        ];
        crawl_rules?: Array<{}>;
        deduplication_settings?: Array<{}>;
    };
    stats: {
        [k: string]: unknown;
    } | null;
};
export interface DeleteCrawlerActiveCrawlRequestRequest {
    /**
     * Name of the engine
     */
    engine_name: string;
}
export interface DeleteCrawlerActiveCrawlRequestResponse {
    id: string;
    type?: 'full' | 'partial';
    status: 'success' | 'failed' | 'canceled' | 'skipped' | 'pending' | 'suspended' | 'starting' | 'running' | 'canceling' | 'suspending';
    created_at: string;
    begun_at: string;
    completed_at: string;
}
export interface CreateCrawlerCrawlRuleRequest {
    /**
     * Name of the engine
     */
    engine_name: string;
    /**
     * Crawler Domain ID
     */
    domain_id: string;
    body?: {
        id?: string;
        order: number;
        policy: 'allow' | 'deny';
        rule: 'begins' | 'ends' | 'contains' | 'regex';
        pattern: string;
        created_at?: string;
    };
}
export interface CreateCrawlerCrawlRuleResponse {
    id?: string;
    order: number;
    policy: 'allow' | 'deny';
    rule: 'begins' | 'ends' | 'contains' | 'regex';
    pattern: string;
    created_at?: string;
}
export interface PutCrawlerCrawlRuleRequest {
    /**
     * Name of the engine
     */
    engine_name: string;
    /**
     * Crawler Domain ID
     */
    domain_id: string;
    /**
     * Crawl Rule ID
     */
    crawl_rule_id: string;
    body?: {
        id?: string;
        order: number;
        policy: 'allow' | 'deny';
        rule: 'begins' | 'ends' | 'contains' | 'regex';
        pattern: string;
        created_at?: string;
    };
}
export interface PutCrawlerCrawlRuleResponse {
    id?: string;
    order: number;
    policy: 'allow' | 'deny';
    rule: 'begins' | 'ends' | 'contains' | 'regex';
    pattern: string;
    created_at?: string;
}
export interface DeleteCrawlerCrawlRuleRequest {
    /**
     * Name of the engine
     */
    engine_name: string;
    /**
     * Crawler Domain ID
     */
    domain_id: string;
    /**
     * Crawl Rule ID
     */
    crawl_rule_id: string;
}
export interface DeleteCrawlerCrawlRuleResponse {
    deleted: boolean;
}
export interface GetCrawlerCrawlScheduleRequest {
    /**
     * Name of the engine
     */
    engine_name: string;
}
export type GetCrawlerCrawlScheduleResponse = {
    frequency: number;
    unit: 'hour' | 'day' | 'week' | 'month';
} & {
    engine: string;
};
export interface PutCrawlerCrawlScheduleRequest {
    /**
     * Name of the engine
     */
    engine_name: string;
    body?: {
        frequency: number;
        unit: 'hour' | 'day' | 'week' | 'month';
    };
}
export type PutCrawlerCrawlScheduleResponse = {
    frequency: number;
    unit: 'hour' | 'day' | 'week' | 'month';
} & {
    engine: string;
};
export interface DeleteCrawlerCrawlScheduleRequest {
    /**
     * Name of the engine
     */
    engine_name: string;
}
export interface DeleteCrawlerCrawlScheduleResponse {
    deleted: boolean;
}
export interface GetCrawlerProcessCrawlDeniedUrlsRequest {
    /**
     * Name of the engine
     */
    engine_name: string;
    /**
     * Process Crawl identifier
     */
    process_crawl_id: string;
}
export interface GetCrawlerProcessCrawlDeniedUrlsResponse {
    /**
     * Total count of URLs analyzed by process crawl
     */
    total_url_count?: number;
    /**
     * Total count of URLs identified for deletion by process crawl
     */
    denied_url_count?: number;
    /**
     * Count of denied URLs provided in sample
     */
    sample_size?: number;
    /**
     * Sample of URLs identified for deletion by process crawl
     */
    denied_urls_sample?: string[];
}
export interface ListCrawlerDomainsRequest {
    /**
     * Name of the engine
     */
    engine_name: string;
    page?: {
        /**
         * The page to fetch. Defaults to 1
         */
        current?: number;
        /**
         * The number of results per page
         */
        size?: number;
    };
}
export interface ListCrawlerDomainsResponse {
    meta: {
        page: {
            current: number;
            total_pages: number;
            total_results: number;
            size: number;
        };
    };
    results: Array<{
        name?: string;
        entry_points?: Array<{
            id?: string;
            value: string;
            created_at?: string;
        }>;
        crawl_rules?: Array<{
            id?: string;
            order: number;
            policy: 'allow' | 'deny';
            rule: 'begins' | 'ends' | 'contains' | 'regex';
            pattern: string;
            created_at?: string;
        }>;
        sitemaps?: Array<{
            id?: string;
            url: string;
            created_at?: string;
        }>;
    } & {
        id?: string;
        document_count?: number;
        deduplication_enabled?: boolean;
        deduplication_fields?: string[];
        available_deduplication_fields?: string[];
        auth?: null | {
            type: 'basic';
            username: string;
            password: string;
        } | {
            type: 'raw';
            header: string;
        };
        created_at?: string;
        last_visited_at?: string;
        default_crawl_rule?: {
            id?: string;
            order: number;
            policy: 'allow' | 'deny';
            rule: 'begins' | 'ends' | 'contains' | 'regex';
            pattern: string;
            created_at?: string;
        };
    }>;
}
export interface CreateCrawlerDomainRequest {
    /**
     * Name of the engine
     */
    engine_name: string;
    body?: {
        name?: string;
        entry_points?: Array<{
            id?: string;
            value: string;
            created_at?: string;
        }>;
        crawl_rules?: Array<{
            id?: string;
            order: number;
            policy: 'allow' | 'deny';
            rule: 'begins' | 'ends' | 'contains' | 'regex';
            pattern: string;
            created_at?: string;
        }>;
        sitemaps?: Array<{
            id?: string;
            url: string;
            created_at?: string;
        }>;
    };
}
export type CreateCrawlerDomainResponse = {
    name?: string;
    entry_points?: Array<{
        id?: string;
        value: string;
        created_at?: string;
    }>;
    crawl_rules?: Array<{
        id?: string;
        order: number;
        policy: 'allow' | 'deny';
        rule: 'begins' | 'ends' | 'contains' | 'regex';
        pattern: string;
        created_at?: string;
    }>;
    sitemaps?: Array<{
        id?: string;
        url: string;
        created_at?: string;
    }>;
} & {
    id?: string;
    document_count?: number;
    deduplication_enabled?: boolean;
    deduplication_fields?: string[];
    available_deduplication_fields?: string[];
    auth?: null | {
        type: 'basic';
        username: string;
        password: string;
    } | {
        type: 'raw';
        header: string;
    };
    created_at?: string;
    last_visited_at?: string;
    default_crawl_rule?: {
        id?: string;
        order: number;
        policy: 'allow' | 'deny';
        rule: 'begins' | 'ends' | 'contains' | 'regex';
        pattern: string;
        created_at?: string;
    };
};
export interface GetCrawlerDomainRequest {
    /**
     * Name of the engine
     */
    engine_name: string;
    /**
     * Crawler Domain ID
     */
    domain_id: string;
}
export type GetCrawlerDomainResponse = {
    name?: string;
    entry_points?: Array<{
        id?: string;
        value: string;
        created_at?: string;
    }>;
    crawl_rules?: Array<{
        id?: string;
        order: number;
        policy: 'allow' | 'deny';
        rule: 'begins' | 'ends' | 'contains' | 'regex';
        pattern: string;
        created_at?: string;
    }>;
    sitemaps?: Array<{
        id?: string;
        url: string;
        created_at?: string;
    }>;
} & {
    id?: string;
    document_count?: number;
    deduplication_enabled?: boolean;
    deduplication_fields?: string[];
    available_deduplication_fields?: string[];
    auth?: null | {
        type: 'basic';
        username: string;
        password: string;
    } | {
        type: 'raw';
        header: string;
    };
    created_at?: string;
    last_visited_at?: string;
    default_crawl_rule?: {
        id?: string;
        order: number;
        policy: 'allow' | 'deny';
        rule: 'begins' | 'ends' | 'contains' | 'regex';
        pattern: string;
        created_at?: string;
    };
};
export interface PutCrawlerDomainRequest {
    /**
     * Name of the engine
     */
    engine_name: string;
    /**
     * Crawler Domain ID
     */
    domain_id: string;
    body?: {
        name?: string;
        entry_points?: Array<{
            id?: string;
            value: string;
            created_at?: string;
        }>;
        crawl_rules?: Array<{
            id?: string;
            order: number;
            policy: 'allow' | 'deny';
            rule: 'begins' | 'ends' | 'contains' | 'regex';
            pattern: string;
            created_at?: string;
        }>;
        sitemaps?: Array<{
            id?: string;
            url: string;
            created_at?: string;
        }>;
    };
}
export type PutCrawlerDomainResponse = {
    name?: string;
    entry_points?: Array<{
        id?: string;
        value: string;
        created_at?: string;
    }>;
    crawl_rules?: Array<{
        id?: string;
        order: number;
        policy: 'allow' | 'deny';
        rule: 'begins' | 'ends' | 'contains' | 'regex';
        pattern: string;
        created_at?: string;
    }>;
    sitemaps?: Array<{
        id?: string;
        url: string;
        created_at?: string;
    }>;
} & {
    id?: string;
    document_count?: number;
    deduplication_enabled?: boolean;
    deduplication_fields?: string[];
    available_deduplication_fields?: string[];
    auth?: null | {
        type: 'basic';
        username: string;
        password: string;
    } | {
        type: 'raw';
        header: string;
    };
    created_at?: string;
    last_visited_at?: string;
    default_crawl_rule?: {
        id?: string;
        order: number;
        policy: 'allow' | 'deny';
        rule: 'begins' | 'ends' | 'contains' | 'regex';
        pattern: string;
        created_at?: string;
    };
};
export interface DeleteCrawlerDomainRequest {
    /**
     * Name of the engine
     */
    engine_name: string;
    /**
     * Crawler Domain ID
     */
    domain_id: string;
}
export interface DeleteCrawlerDomainResponse {
    deleted: boolean;
}
export interface CreateCrawlerEntryPointRequest {
    /**
     * Name of the engine
     */
    engine_name: string;
    /**
     * Crawler Domain ID
     */
    domain_id: string;
    body?: {
        id?: string;
        value: string;
        created_at?: string;
    };
}
export interface CreateCrawlerEntryPointResponse {
    id?: string;
    value: string;
    created_at?: string;
}
export interface PutCrawlerEntryPointRequest {
    /**
     * Name of the engine
     */
    engine_name: string;
    /**
     * Crawler Domain ID
     */
    domain_id: string;
    /**
     * Crawler Entry Point identifier
     */
    entry_point_id: string;
    body?: {
        id?: string;
        value: string;
        created_at?: string;
    };
}
export interface PutCrawlerEntryPointResponse {
    id?: string;
    value: string;
    created_at?: string;
}
export interface DeleteCrawlerEntryPointRequest {
    /**
     * Name of the engine
     */
    engine_name: string;
    /**
     * Crawler Domain ID
     */
    domain_id: string;
    /**
     * Crawler Entry Point identifier
     */
    entry_point_id: string;
}
export interface DeleteCrawlerEntryPointResponse {
    deleted: boolean;
}
export interface GetCrawlerMetricsRequest {
}
export interface GetCrawlerMetricsResponse {
    global: {
        crawl_requests: {
            pending: number;
            active: number;
            successful: number;
            failed: number;
        };
    };
    node: {
        workers: {
            pool_size: number;
            active: number;
            available: number;
        };
        active_crawls: Array<{
            worker_id?: string;
            worker_running?: boolean;
            crawl_request?: {
                id: string;
                status: 'success' | 'failed' | 'canceled' | 'skipped' | 'pending' | 'suspended' | 'starting' | 'running' | 'canceling' | 'suspending';
                created_at: string;
                updated_at: string;
                begun_at: string;
                engine: {
                    id: string;
                    name: string;
                };
            };
            crawl_status?: {
                queue_size?: number;
                pages_visited?: number;
                urls_allowed?: number;
                crawl_duration_msec?: {
                    [k: string]: unknown;
                };
                crawling_time_msec?: {
                    [k: string]: unknown;
                };
                avg_response_time_msec?: {
                    [k: string]: unknown;
                };
                active_threads?: number;
                urls_denied?: {
                    [k: string]: number;
                };
                status_codes?: {
                    [k: string]: number;
                };
                http_client?: {
                    max_connections?: number;
                    used_connections?: number;
                };
            };
            purge_crawl_status?: {
                queue_size?: number;
                pages_visited?: number;
                urls_allowed?: number;
                crawl_duration_msec?: {
                    [k: string]: unknown;
                };
                crawling_time_msec?: {
                    [k: string]: unknown;
                };
                avg_response_time_msec?: {
                    [k: string]: unknown;
                };
                active_threads?: number;
                urls_denied?: {
                    [k: string]: number;
                };
                status_codes?: {
                    [k: string]: number;
                };
                http_client?: {
                    max_connections?: number;
                    used_connections?: number;
                };
            };
        }>;
        stats: {
            active_threads?: number;
            pages_visited?: number;
            urls_allowed?: number;
            queue_size?: {
                primary: number;
                purge: number;
            };
            urls_denied?: {
                [k: string]: number;
            };
            status_codes?: {
                [k: string]: number;
            };
        };
    };
}
export interface GetCrawlerOverviewRequest {
    /**
     * Name of the engine
     */
    engine_name: string;
}
export interface GetCrawlerOverviewResponse {
    domains: Array<{
        name?: string;
        entry_points?: Array<{
            id?: string;
            value: string;
            created_at?: string;
        }>;
        crawl_rules?: Array<{
            id?: string;
            order: number;
            policy: 'allow' | 'deny';
            rule: 'begins' | 'ends' | 'contains' | 'regex';
            pattern: string;
            created_at?: string;
        }>;
        sitemaps?: Array<{
            id?: string;
            url: string;
            created_at?: string;
        }>;
    }>;
    events: Array<{}>;
    most_recent_crawl_request: null | {
        id: string;
        type?: 'full' | 'partial';
        status: 'success' | 'failed' | 'canceled' | 'skipped' | 'pending' | 'suspended' | 'starting' | 'running' | 'canceling' | 'suspending';
        created_at: string;
        begun_at: string;
        completed_at: string;
    };
}
export interface CreateCrawlerProcessCrawlRequest {
    /**
     * Name of the engine
     */
    engine_name: string;
    body?: {
        dry_run?: boolean;
        domains?: string[];
    };
}
export interface CreateCrawlerProcessCrawlResponse {
    id?: string;
    dry_run?: boolean;
    total_url_count?: number;
    denied_url_count?: number;
    domains?: string[];
    process_all_domains?: boolean;
    created_at?: string;
    begun_at?: string;
    completed_at?: string;
}
export interface ListCrawlerProcessCrawlsRequest {
    /**
     * Name of the engine
     */
    engine_name: string;
    page?: {
        /**
         * The page to fetch. Defaults to 1
         */
        current?: number;
        /**
         * The number of results per page
         */
        size?: number;
    };
}
export interface ListCrawlerProcessCrawlsResponse {
    meta: {
        page: {
            current: number;
            total_pages: number;
            total_results: number;
            size: number;
        };
    };
    results: Array<{
        id?: string;
        dry_run?: boolean;
        total_url_count?: number;
        denied_url_count?: number;
        domains?: string[];
        process_all_domains?: boolean;
        created_at?: string;
        begun_at?: string;
        completed_at?: string;
    }>;
}
export interface GetCrawlerProcessCrawlRequest {
    /**
     * Name of the engine
     */
    engine_name: string;
    /**
     * Process Crawl identifier
     */
    process_crawl_id: string;
}
export interface GetCrawlerProcessCrawlResponse {
    id?: string;
    dry_run?: boolean;
    total_url_count?: number;
    denied_url_count?: number;
    domains?: string[];
    process_all_domains?: boolean;
    created_at?: string;
    begun_at?: string;
    completed_at?: string;
}
export interface CreateCrawlerSitemapRequest {
    /**
     * Name of the engine
     */
    engine_name: string;
    /**
     * Crawler Domain ID
     */
    domain_id: string;
    body?: {
        id?: string;
        url: string;
        created_at?: string;
    };
}
export interface CreateCrawlerSitemapResponse {
    id?: string;
    url: string;
    created_at?: string;
}
export interface PutCrawlerSitemapRequest {
    /**
     * Name of the engine
     */
    engine_name: string;
    /**
     * Crawler Domain ID
     */
    domain_id: string;
    /**
     * Sitemap ID
     */
    sitemap_id: string;
    body?: {
        id?: string;
        url: string;
        created_at?: string;
    };
}
export interface PutCrawlerSitemapResponse {
    id?: string;
    url: string;
    created_at?: string;
}
export interface DeleteCrawlerSitemapRequest {
    /**
     * Name of the engine
     */
    engine_name: string;
    /**
     * Crawler Domain ID
     */
    domain_id: string;
    /**
     * Sitemap ID
     */
    sitemap_id: string;
}
export interface DeleteCrawlerSitemapResponse {
    deleted: boolean;
}
export interface GetCrawlerUrlTracingResultRequest {
    /**
     * Name of the engine
     */
    engine_name: string;
    body: string;
}
export interface GetCrawlerUrlTracingResultResponse {
    url: string;
    normalized_url: string;
    crawl_requests: Array<{
        crawl_request: {
            id: string;
            type?: 'full' | 'partial';
            status: 'success' | 'failed' | 'canceled' | 'skipped' | 'pending' | 'suspended' | 'starting' | 'running' | 'canceling' | 'suspending';
            created_at: string;
            begun_at: string;
            completed_at: string;
        };
        found: boolean;
        discover: Array<{
            timestamp: string;
            event_id: string;
            message: string;
        } & {
            event_type: string;
            crawl_depth: number;
            source_url: string;
            deny_reason: string;
        }>;
        seed: {
            timestamp: string;
            event_id: string;
            message: string;
        } & {
            url_type: string;
            source_type: string;
            source_url: string;
        };
        fetch: {
            timestamp: string;
            event_id: string;
            message: string;
        } & {
            event_outcome: string;
            duration_msec: {
                [k: string]: unknown;
            };
            http_response: {
                status_code: number;
                body_bytes: number;
            };
            redirect: {
                timestamp: string;
                event_id: string;
                message: string;
            } & {
                location: string;
                count: number;
                chain: string[];
            };
        };
        output: {
            timestamp: string;
            event_id: string;
            message: string;
        } & {
            event_outcome?: string;
            output_module?: string;
            duration_msec?: {
                [k: string]: unknown;
            };
            engine?: {
                id: string;
                name: string;
            };
            document?: {
                id: string;
            };
        };
    }>;
}
export interface GetCrawlerUrlValidationResultRequest {
    /**
     * Name of the engine
     */
    engine_name: string;
    body: string;
}
export interface GetCrawlerUrlValidationResultResponse {
    url: string;
    normalized_url: string;
    valid: boolean;
    results: Array<{
        name: string;
        result: string;
        comment: string;
        details?: {};
    }>;
}
export interface GetCrawlerDomainValidationResultRequest {
    body: string;
}
export interface GetCrawlerDomainValidationResultResponse {
    url: string;
    normalized_url: string;
    valid: boolean;
    results: Array<{
        name: string;
        result: string;
        comment: string;
        details?: {};
    }>;
}
export interface GetCrawlerUserAgentRequest {
}
export interface GetCrawlerUserAgentResponse {
    user_agent: string;
}
export interface ListApiKeysRequest {
    page?: {
        /**
         * The page to fetch. Defaults to 1
         */
        current?: number;
        /**
         * The number of results per page
         */
        size?: number;
    };
}
export interface ListApiKeysResponse {
    meta: {
        page: {
            current: number;
            total_pages: number;
            total_results: number;
            size: number;
        };
    };
    results: Array<{
        id?: string;
        name: string;
        type: 'private' | 'search' | 'admin';
        access_all_engines?: boolean;
        engines?: string[];
        write?: boolean;
        read?: boolean;
    }>;
}
export interface CreateApiKeyRequest {
    /**
     * Details of an API key
     */
    body?: {
        id?: string;
        name: string;
        type: 'private' | 'search' | 'admin';
        access_all_engines?: boolean;
        engines?: string[];
        write?: boolean;
        read?: boolean;
    };
}
/**
 * Details of an API key
 */
export interface CreateApiKeyResponse {
    id?: string;
    name: string;
    type: 'private' | 'search' | 'admin';
    access_all_engines?: boolean;
    engines?: string[];
    write?: boolean;
    read?: boolean;
}
export interface GetApiKeyRequest {
    /**
     * Name of an API key
     */
    api_key_name: string;
}
/**
 * Details of an API key
 */
export interface GetApiKeyResponse {
    id?: string;
    name: string;
    type: 'private' | 'search' | 'admin';
    access_all_engines?: boolean;
    engines?: string[];
    write?: boolean;
    read?: boolean;
}
export interface PutApiKeyRequest {
    /**
     * Name of an API key
     */
    api_key_name: string;
    /**
     * Details of an API key
     */
    body?: {
        id?: string;
        name: string;
        type: 'private' | 'search' | 'admin';
        access_all_engines?: boolean;
        engines?: string[];
        write?: boolean;
        read?: boolean;
    };
}
/**
 * Details of an API key
 */
export interface PutApiKeyResponse {
    id?: string;
    name: string;
    type: 'private' | 'search' | 'admin';
    access_all_engines?: boolean;
    engines?: string[];
    write?: boolean;
    read?: boolean;
}
export interface DeleteApiKeyRequest {
    /**
     * Name of an API key
     */
    api_key_name: string;
}
export interface DeleteApiKeyResponse {
    deleted: boolean;
}
export interface ListCurationsRequest {
    /**
     * Name of the engine
     */
    engine_name: string;
    page?: {
        /**
         * The page to fetch. Defaults to 1
         */
        current?: number;
        /**
         * The number of results per page
         */
        size?: number;
    };
}
export interface ListCurationsResponse {
    meta: {
        page: {
            current: number;
            total_pages: number;
            total_results: number;
            size: number;
        };
    };
    results: Array<{
        id?: string;
        /**
         * List of affected search queries
         */
        queries: string[];
        /**
         * List of promoted document IDs
         */
        promoted?: string[];
        /**
         * List of hidden document IDs
         */
        hidden?: string[];
        suggestion?: {
            query?: string;
            status?: 'pending' | 'applied' | 'automated' | 'rejected' | 'disabled';
            updated_at?: string;
            created_at?: string;
        };
    }>;
}
export interface CreateCurationRequest {
    /**
     * Name of the engine
     */
    engine_name: string;
    body?: {
        id?: string;
        /**
         * List of affected search queries
         */
        queries: string[];
        /**
         * List of promoted document IDs
         */
        promoted?: string[];
        /**
         * List of hidden document IDs
         */
        hidden?: string[];
        suggestion?: {
            query?: string;
            status?: 'pending' | 'applied' | 'automated' | 'rejected' | 'disabled';
            updated_at?: string;
            created_at?: string;
        };
    };
}
export interface CreateCurationResponse {
    id: string;
}
export interface GetCurationRequest {
    /**
     * Name of the engine
     */
    engine_name: string;
    /**
     * Curation ID
     */
    curation_id: string;
}
export interface GetCurationResponse {
    id?: string;
    /**
     * List of affected search queries
     */
    queries: string[];
    /**
     * List of promoted document IDs
     */
    promoted?: string[];
    /**
     * List of hidden document IDs
     */
    hidden?: string[];
    suggestion?: {
        query?: string;
        status?: 'pending' | 'applied' | 'automated' | 'rejected' | 'disabled';
        updated_at?: string;
        created_at?: string;
    };
}
export interface PutCurationRequest {
    /**
     * Name of the engine
     */
    engine_name: string;
    /**
     * Curation ID
     */
    curation_id: string;
    body?: {
        id?: string;
        /**
         * List of affected search queries
         */
        queries: string[];
        /**
         * List of promoted document IDs
         */
        promoted?: string[];
        /**
         * List of hidden document IDs
         */
        hidden?: string[];
        suggestion?: {
            query?: string;
            status?: 'pending' | 'applied' | 'automated' | 'rejected' | 'disabled';
            updated_at?: string;
            created_at?: string;
        };
    };
}
export interface PutCurationResponse {
    id: string;
}
export interface DeleteCurationRequest {
    /**
     * Name of the engine
     */
    engine_name: string;
    /**
     * Curation ID
     */
    curation_id: string;
}
export interface DeleteCurationResponse {
    deleted: boolean;
}
export interface GetDocumentsRequest {
    /**
     * Name of the engine
     */
    engine_name: string;
    /**
     * List of Document IDs to fetch
     */
    ids?: unknown[];
    documentIds?: string[];
}
export type GetDocumentsResponse = Array<null | {
    [k: string]: unknown;
}>;
export interface IndexDocumentsRequest {
    /**
     * Name of the engine
     */
    engine_name: string;
    documents?: Array<{
        [k: string]: unknown;
    }>;
}
export type IndexDocumentsResponse = Array<{
    id: string;
}>;
export interface DeleteDocumentsRequest {
    /**
     * Name of the engine
     */
    engine_name: string;
    documentIds?: string[];
}
export type DeleteDocumentsResponse = Array<{
    id: string;
    deleted: boolean;
}>;
export interface PutDocumentsRequest {
    /**
     * Name of the engine
     */
    engine_name: string;
    documents?: Array<{
        [k: string]: unknown;
    }>;
}
export type PutDocumentsResponse = Array<{
    id: string;
}>;
export interface ListDocumentsRequest {
    /**
     * Name of the engine
     */
    engine_name: string;
    page?: {
        /**
         * The page to fetch. Defaults to 1
         */
        current?: number;
        /**
         * The number of results per page
         */
        size?: number;
    };
}
export interface ListDocumentsResponse {
    meta: {
        page: {
            current: number;
            total_pages: number;
            total_results: number;
            size: number;
        };
    };
    results: Array<{
        [k: string]: unknown;
    }>;
}
export interface ListEnginesRequest {
    page?: {
        /**
         * The page to fetch. Defaults to 1
         */
        current?: number;
        /**
         * The number of results per page
         */
        size?: number;
    };
}
export interface ListEnginesResponse {
    meta: {
        page: {
            current: number;
            total_pages: number;
            total_results: number;
            size: number;
        };
    };
    results: Array<{
        name: string;
        /**
         * Engine language (null for universal)
         */
        language?: 'da' | 'de' | 'en' | 'es' | 'fr' | 'it' | 'ja' | 'ko' | 'nl' | 'pt' | 'pt-br' | 'ru' | 'th' | 'zh' | null;
        /**
         * Engine type
         */
        type?: 'meta' | 'default';
        source_engines?: string[];
        document_count?: number;
        index_create_settings_override?: {
            number_of_shards?: number;
        };
    }>;
}
export interface CreateEngineRequest {
    body?: {
        name: string;
        /**
         * Engine language (null for universal)
         */
        language?: 'da' | 'de' | 'en' | 'es' | 'fr' | 'it' | 'ja' | 'ko' | 'nl' | 'pt' | 'pt-br' | 'ru' | 'th' | 'zh' | null;
        /**
         * Engine type
         */
        type?: 'meta' | 'default';
        source_engines?: string[];
        document_count?: number;
        index_create_settings_override?: {
            number_of_shards?: number;
        };
    };
}
export interface CreateEngineResponse {
    name: string;
    /**
     * Engine language (null for universal)
     */
    language?: 'da' | 'de' | 'en' | 'es' | 'fr' | 'it' | 'ja' | 'ko' | 'nl' | 'pt' | 'pt-br' | 'ru' | 'th' | 'zh' | null;
    /**
     * Engine type
     */
    type?: 'meta' | 'default';
    source_engines?: string[];
    document_count?: number;
    index_create_settings_override?: {
        number_of_shards?: number;
    };
}
export interface GetEngineRequest {
    /**
     * Name of the engine
     */
    engine_name: string;
}
export interface GetEngineResponse {
    name: string;
    /**
     * Engine language (null for universal)
     */
    language?: 'da' | 'de' | 'en' | 'es' | 'fr' | 'it' | 'ja' | 'ko' | 'nl' | 'pt' | 'pt-br' | 'ru' | 'th' | 'zh' | null;
    /**
     * Engine type
     */
    type?: 'meta' | 'default';
    source_engines?: string[];
    document_count?: number;
    index_create_settings_override?: {
        number_of_shards?: number;
    };
}
export interface DeleteEngineRequest {
    /**
     * Name of the engine
     */
    engine_name: string;
}
export interface DeleteEngineResponse {
    deleted: boolean;
}
export interface DeleteMetaEngineSourceRequest {
    /**
     * Name of the engine
     */
    engine_name: string;
    sourceEngines?: string[];
}
export interface DeleteMetaEngineSourceResponse {
    name: string;
    /**
     * Engine language (null for universal)
     */
    language?: 'da' | 'de' | 'en' | 'es' | 'fr' | 'it' | 'ja' | 'ko' | 'nl' | 'pt' | 'pt-br' | 'ru' | 'th' | 'zh' | null;
    /**
     * Engine type
     */
    type?: 'meta' | 'default';
    source_engines?: string[];
    document_count?: number;
    index_create_settings_override?: {
        number_of_shards?: number;
    };
}
export interface AddMetaEngineSourceRequest {
    /**
     * Name of the engine
     */
    engine_name: string;
    sourceEngines?: string[];
}
export interface AddMetaEngineSourceResponse {
    name: string;
    /**
     * Engine language (null for universal)
     */
    language?: 'da' | 'de' | 'en' | 'es' | 'fr' | 'it' | 'ja' | 'ko' | 'nl' | 'pt' | 'pt-br' | 'ru' | 'th' | 'zh' | null;
    /**
     * Engine type
     */
    type?: 'meta' | 'default';
    source_engines?: string[];
    document_count?: number;
    index_create_settings_override?: {
        number_of_shards?: number;
    };
}
export interface SearchEsSearchRequest {
    /**
     * Name of the engine
     */
    engine_name: string;
    /**
     * Query parameters to be passed to Elasticsearch _search API
     */
    es_search_query_params?: {
        [k: string]: unknown;
    };
    /**
     * The search query associated with this request when recording search analytics
     */
    'X-Enterprise-Search-Analytics'?: {
        [k: string]: unknown;
    };
    /**
     * Analytics tags to be applied with this search request
     */
    'X-Enterprise-Search-Analytics-Tags'?: {
        [k: string]: unknown;
    };
    /**
     * The Elasticsearch token API
     */
    Authorization: {
        [k: string]: unknown;
    };
    body?: {};
}
export type SearchEsSearchResponse = Record<string, unknown>;
export interface GetApiLogsRequest {
    /**
     * Name of the engine
     */
    engine_name: string;
    body?: {
        filters: {
            date: {
                from: string;
                to: string;
            };
            status?: number;
            method?: 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
        };
        page?: {
            total_results?: number;
            size?: number;
        };
        query?: string;
        sort_direction?: 'asc' | 'desc';
    };
}
export interface GetApiLogsResponse {
    results?: Array<{}>;
    meta?: {
        page: {
            current: number;
            total_pages: number;
            total_results: number;
            size: number;
        };
    } & {
        query?: string;
        filters?: {
            date: {
                from: string;
                to: string;
            };
            status?: number;
            method?: 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
        };
        sort_direction?: 'asc' | 'desc';
    };
}
export interface QuerySuggestionRequest {
    /**
     * Name of the engine
     */
    engine_name: string;
    body?: {
        query?: string;
        types?: {
            documents?: {
                fields?: string[];
                [k: string]: unknown;
            };
            [k: string]: unknown;
        };
        size?: number;
    };
}
export interface QuerySuggestionResponse {
    results?: {
        documents?: Array<{
            suggestion?: string;
        }>;
        [k: string]: unknown;
    };
    meta?: {};
}
export interface GetSchemaRequest {
    /**
     * Name of the engine
     */
    engine_name: string;
}
export interface GetSchemaResponse {
    [k: string]: string;
}
export interface PutSchemaRequest {
    /**
     * Name of the engine
     */
    engine_name: string;
    schema?: {
        [k: string]: 'text' | 'number' | 'date' | 'geolocation';
    };
}
export interface PutSchemaResponse {
    [k: string]: string;
}
export interface SearchRequest {
    /**
     * Name of the engine
     */
    engine_name: string;
    body?: {
        query: string;
        analytics?: {};
        boosts?: {};
        facets?: {};
        filters?: {};
        group?: {};
        page?: {
            current?: number;
            size?: number;
        };
        result_fields?: {};
        search_fields?: {
            [k: string]: {
                weight?: number;
            };
        };
        sort?: Array<{
            [k: string]: ('asc' | 'desc') | {
                center?: string | Array<{
                    [k: string]: unknown;
                }>;
                order?: 'asc' | 'desc';
                mode?: 'min' | 'max' | 'median' | 'avg';
            };
        }>;
    };
}
export interface SearchResponse {
    meta: {
        page: {
            current: number;
            total_pages: number;
            total_results: number;
            size: number;
        };
    } & {
        alerts: string[];
        warnings: string[];
        precision?: number;
        engine: {
            name?: string;
            /**
             * Engine type
             */
            type?: 'meta' | 'default';
        };
        request_id?: string;
    };
    results: Array<{}>;
}
export interface MultiSearchRequest {
    /**
     * Name of the engine
     */
    engine_name: string;
    body?: {
        queries: Array<{
            query: string;
            analytics?: {};
            boosts?: {};
            facets?: {};
            filters?: {};
            group?: {};
            page?: {
                current?: number;
                size?: number;
            };
            result_fields?: {};
            search_fields?: {
                [k: string]: {
                    weight?: number;
                };
            };
            sort?: Array<{
                [k: string]: ('asc' | 'desc') | {
                    center?: string | Array<{
                        [k: string]: unknown;
                    }>;
                    order?: