1use chrono::{DateTime, NaiveDate, Utc};
2use serde::{Deserialize, Serialize};
3use std::collections::HashMap;
4
5#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
11pub struct UserResponse {
12 pub user_id: i64,
14}
15
16#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
22pub struct HostsResponse {
23 pub hosts: Vec<HostInfo>,
25}
26
27#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq)]
29#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
30pub enum HostDataStatus {
31 NotIndexed,
33 NotLoaded,
35 Ok,
37}
38
39#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
41pub struct HostInfo {
42 pub host_id: String,
44 pub ascii_host_url: String,
46 pub unicode_host_url: String,
48 pub verified: bool,
50 #[serde(skip_serializing_if = "Option::is_none")]
52 pub main_mirror: Option<Box<HostInfo>>,
53}
54
55#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
57pub struct FullHostInfo {
58 pub host_id: String,
60 pub ascii_host_url: String,
62 pub unicode_host_url: String,
64 pub verified: bool,
66 #[serde(skip_serializing_if = "Option::is_none")]
68 pub main_mirror: Option<Box<HostInfo>>,
69 pub host_data_status: Option<HostDataStatus>,
71 pub host_display_name: Option<String>,
73}
74
75#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
77pub struct AddHostResponse {
78 pub host_id: String,
80}
81
82#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
88pub struct FailInfo {
89 pub message: String,
91 pub reason: VerificationFailReason,
93}
94#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
96pub struct HostVerificationStatusResponse {
97 pub verification_state: VerificationState,
99 pub verification_type: VerificationType,
101 pub verification_uin: String,
103 pub applicable_verifiers: Vec<ExplicitVerificationType>,
105 pub latest_verification_time: Option<DateTime<Utc>>,
107 pub fail_info: Option<FailInfo>,
109}
110
111#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
113pub struct HostVerificationResponse {
114 pub verification_state: VerificationState,
116 pub verification_type: VerificationType,
118 pub verification_uin: String,
120 pub applicable_verifiers: Vec<ExplicitVerificationType>,
122}
123
124#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq)]
126#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
127pub enum VerificationState {
128 None,
130 Verified,
132 InProgress,
134 VerificationFailed,
136 InternalError,
138}
139
140#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq)]
142#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
143pub enum ExplicitVerificationType {
144 Dns,
146 MetaTag,
148 HtmlFile,
150}
151
152#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq)]
154#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
155pub enum VerificationType {
156 Auto,
158 Delegated,
160 Pdd,
162 TxtFile,
164 Dns,
166 MetaTag,
168 HtmlFile,
170}
171
172#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq)]
174#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
175pub enum VerificationFailReason {
176 DelegationCancelled,
178 DnsRecordNotFound,
180 MetaTagNotFound,
182 WrongHtmlPageContent,
184 PddVerificationCancelled,
186}
187
188#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
190pub struct OwnersResponse {
191 pub users: Vec<Owner>,
193}
194
195#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
197pub struct Owner {
198 pub user_login: String,
200 pub verification_uin: String,
202 pub verification_type: VerificationType,
204 #[serde(skip_serializing_if = "Option::is_none")]
206 pub verification_date: Option<DateTime<Utc>>,
207}
208
209#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
215pub struct HostSummaryResponse {
216 #[serde(skip_serializing_if = "Option::is_none")]
218 pub sqi: Option<f64>,
219 #[serde(default)]
221 pub searchable_pages_count: i64,
222 #[serde(default)]
224 pub excluded_pages_count: i64,
225 #[serde(default)]
227 pub site_problems: HashMap<SiteProblemSeverityEnum, i32>,
228}
229
230#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
232pub struct ExcludedPagesStatistics {
233 pub statuses: HashMap<ApiExcludedUrlStatus, i64>,
235}
236
237#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Default)]
239pub struct SqiHistoryRequest {
240 pub date_from: Option<DateTime<Utc>>,
241 pub date_to: Option<DateTime<Utc>>,
242}
243
244#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
246pub struct SqiHistoryResponse {
247 pub points: Vec<SqiPoint>,
249}
250
251#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
253pub struct SqiPoint {
254 pub date: DateTime<Utc>,
256 pub value: f64,
258}
259
260#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq)]
266#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
267pub enum ApiQueryOrderField {
268 TotalShows,
270 TotalClicks,
272}
273
274#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq, Hash)]
276#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
277pub enum ApiQueryIndicator {
278 TotalShows,
280 TotalClicks,
282 AvgShowPosition,
284 AvgClickPosition,
286}
287
288#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq, Default)]
290#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
291pub enum ApiDeviceTypeIndicator {
292 #[default]
294 All,
295 Desktop,
297 MobileAndTablet,
299 Mobile,
301 Tablet,
303}
304
305#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
307pub struct PopularQueriesRequest {
308 pub order_by: ApiQueryOrderField,
310 #[serde(skip_serializing_if = "Option::is_none")]
312 pub query_indicator: Option<ApiQueryIndicator>,
313 #[serde(skip_serializing_if = "Option::is_none")]
315 pub device_type_indicator: Option<ApiDeviceTypeIndicator>,
316 #[serde(skip_serializing_if = "Option::is_none")]
318 pub date_from: Option<NaiveDate>,
319 #[serde(skip_serializing_if = "Option::is_none")]
321 pub date_to: Option<NaiveDate>,
322 #[serde(skip_serializing_if = "Option::is_none")]
324 pub offset: Option<i32>,
325 #[serde(skip_serializing_if = "Option::is_none")]
327 pub limit: Option<i32>,
328}
329
330#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
332pub struct PopularQueriesResponse {
333 pub queries: Vec<PopularQuery>,
335 pub date_from: NaiveDate,
337 pub date_to: NaiveDate,
339 pub count: i32,
341}
342
343#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
345pub struct PopularQuery {
346 pub query_id: String,
348 pub query_text: String,
350 pub indicators: std::collections::HashMap<ApiQueryIndicator, f64>,
352}
353
354#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
356pub struct QueryAnalyticsRequest {
357 pub query_indicator: Vec<ApiQueryIndicator>,
359 #[serde(skip_serializing_if = "Option::is_none")]
361 pub device_type_indicator: Option<ApiDeviceTypeIndicator>,
362 #[serde(skip_serializing_if = "Option::is_none")]
364 pub date_from: Option<DateTime<Utc>>,
365 #[serde(skip_serializing_if = "Option::is_none")]
367 pub date_to: Option<DateTime<Utc>>,
368}
369
370#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
372pub struct QueryAnalyticsResponse {
373 pub indicators: std::collections::HashMap<ApiQueryIndicator, Vec<IndicatorPoint>>,
375}
376
377#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
379pub struct IndicatorPoint {
380 pub date: DateTime<Utc>,
382 pub value: f64,
384}
385
386#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
388pub struct QueryHistoryRequest {
389 pub query_indicator: Vec<ApiQueryIndicator>,
391 #[serde(skip_serializing_if = "Option::is_none")]
393 pub device_type_indicator: Option<ApiDeviceTypeIndicator>,
394 #[serde(skip_serializing_if = "Option::is_none")]
396 pub date_from: Option<NaiveDate>,
397 #[serde(skip_serializing_if = "Option::is_none")]
399 pub date_to: Option<NaiveDate>,
400}
401
402#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
404pub struct QueryHistoryResponse {
405 pub query_id: String,
407 pub query_text: String,
409 pub indicators: std::collections::HashMap<ApiQueryIndicator, Vec<IndicatorPoint>>,
411}
412
413#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq)]
419#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
420pub enum ApiSitemapSource {
421 RobotsTxt,
423 Webmaster,
425 IndexSitemap,
427}
428
429#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq)]
431#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
432pub enum ApiSitemapType {
433 Sitemap,
435 IndexSitemap,
437}
438
439#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, Default)]
441pub struct GetSitemapsRequest {
442 #[serde(skip_serializing_if = "Option::is_none")]
444 pub parent_id: Option<String>,
445 #[serde(skip_serializing_if = "Option::is_none")]
447 pub limit: Option<i32>,
448 #[serde(skip_serializing_if = "Option::is_none")]
450 pub from: Option<String>,
451}
452
453#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
455pub struct SitemapsResponse {
456 pub sitemaps: Vec<SitemapInfo>,
458}
459
460#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
462pub struct SitemapInfo {
463 pub sitemap_id: String,
465 pub sitemap_url: String,
467 #[serde(skip_serializing_if = "Option::is_none")]
469 pub last_access_date: Option<DateTime<Utc>>,
470 pub errors_count: i32,
472 pub urls_count: i64,
474 pub children_count: i32,
476 pub sources: Vec<ApiSitemapSource>,
478 pub sitemap_type: ApiSitemapType,
480}
481
482#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, Default)]
484pub struct GetUserSitemapsRequest {
485 #[serde(skip_serializing_if = "Option::is_none")]
487 pub offset: Option<i32>,
488 #[serde(skip_serializing_if = "Option::is_none")]
490 pub limit: Option<i32>,
491}
492
493#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
495pub struct UserSitemapsResponse {
496 pub sitemaps: Vec<UserSitemapInfo>,
498 pub count: i32,
500}
501
502#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
504pub struct UserSitemapInfo {
505 pub sitemap_id: String,
507 pub sitemap_url: String,
509 pub added_date: DateTime<Utc>,
511}
512
513#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
515pub struct AddSitemapResponse {
516 pub sitemap_id: String,
518}
519
520#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq, Hash)]
526#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
527pub enum IndexingStatusEnum {
528 #[serde(rename = "HTTP_2XX")]
530 Http2xx,
531 #[serde(rename = "HTTP_3XX")]
533 Http3xx,
534 #[serde(rename = "HTTP_4XX")]
536 Http4xx,
537 #[serde(rename = "HTTP_5XX")]
539 Http5xx,
540 Other,
542}
543
544#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq, Hash)]
546#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
547pub enum SiteProblemSeverityEnum {
548 Fatal,
550 Critical,
552 PossibleProblem,
554 Recommendation,
556}
557
558#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq, Hash)]
560#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
561pub enum ApiExcludedUrlStatus {
562 NothingFound,
564 HostError,
566 RedirectNotsearchable,
568 HttpError,
570 NotCanonical,
572 NotMainMirror,
574 ParserError,
576 RobotsHostError,
578 RobotsUrlError,
580 Duplicate,
582 CleanParams,
584 NoIndex,
586 ForbiddenByRobotsTxt,
588 UrlNotAllowed,
590 ContainsNoindexMetaTag,
592 ContainsNoindexXRobotsTagHeader,
594 SitemapForbidden,
596 SitemapNotAllowed,
598 LowQuality,
600 AlternativeDuplicate,
602 UserDuplicate,
604 CanonicalDuplicate,
606 RedirectDuplicate,
608 MovedPermanently,
610 MovedTemporarily,
612 MalwareDetected,
614 PhishingDetected,
616 AdultContent,
618 Other,
620}
621
622#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq, Hash)]
624#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
625pub enum ApiImportantUrlChangeIndicator {
626 IndexingHttpCode,
628 SearchStatus,
630 Title,
632 Description,
634}
635
636#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Default)]
638pub struct IndexingHistoryRequest {
639 #[serde(skip_serializing_if = "Option::is_none")]
641 pub date_from: Option<DateTime<Utc>>,
642 #[serde(skip_serializing_if = "Option::is_none")]
644 pub date_to: Option<DateTime<Utc>>,
645}
646
647#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
649pub struct IndexingHistoryResponse {
650 pub indicators: HashMap<IndexingStatusEnum, Vec<IndexingHistoryPoint>>,
652}
653
654#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
656pub struct IndexingHistoryPoint {
657 pub date: DateTime<Utc>,
659 pub value: f64,
661}
662
663#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, Default)]
665pub struct GetIndexingSamplesRequest {
666 #[serde(skip_serializing_if = "Option::is_none")]
668 pub offset: Option<i32>,
669 #[serde(skip_serializing_if = "Option::is_none")]
671 pub limit: Option<i32>,
672}
673
674#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
676pub struct IndexingSamplesResponse {
677 pub samples: Vec<IndexingSample>,
679 pub count: i32,
681}
682
683#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
685pub struct IndexingSample {
686 pub url: String,
688 pub http_code: i32,
690 pub access_date: DateTime<Utc>,
692}
693
694#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq, Hash)]
700#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
701pub enum ApiSearchEventEnum {
702 AppearedInSearch,
704 RemovedFromSearch,
706}
707
708#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
710pub struct SearchUrlsHistoryResponse {
711 pub history: Vec<SearchUrlsHistoryPoint>,
713}
714
715#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
717pub struct SearchUrlsHistoryPoint {
718 pub date: DateTime<Utc>,
720 pub value: i64,
722}
723
724#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, Default)]
726pub struct GetSearchUrlsSamplesRequest {
727 #[serde(skip_serializing_if = "Option::is_none")]
729 pub offset: Option<i32>,
730 #[serde(skip_serializing_if = "Option::is_none")]
732 pub limit: Option<i32>,
733}
734
735#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
737pub struct SearchUrlsSamplesResponse {
738 pub count: i32,
740 pub samples: Vec<SearchUrlsSample>,
742}
743
744#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
746pub struct SearchUrlsSample {
747 pub url: String,
749 pub last_access: DateTime<Utc>,
751 pub title: String,
753}
754
755#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
757pub struct SearchEventsHistoryResponse {
758 pub indicators: HashMap<ApiSearchEventEnum, Vec<SearchUrlsHistoryPoint>>,
760}
761
762#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, Default)]
764pub struct GetSearchEventsSamplesRequest {
765 #[serde(skip_serializing_if = "Option::is_none")]
767 pub offset: Option<i32>,
768 #[serde(skip_serializing_if = "Option::is_none")]
770 pub limit: Option<i32>,
771}
772
773#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
775pub struct SearchEventsSamplesResponse {
776 pub count: i32,
778 pub samples: Vec<SearchEventsSample>,
780}
781
782#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
784pub struct SearchEventsSample {
785 pub url: String,
787 pub title: String,
789 pub event_date: DateTime<Utc>,
791 pub last_access: DateTime<Utc>,
793 pub event: ApiSearchEventEnum,
795 #[serde(skip_serializing_if = "Option::is_none")]
797 pub excluded_url_status: Option<ApiExcludedUrlStatus>,
798 #[serde(skip_serializing_if = "Option::is_none")]
800 pub bad_http_status: Option<i32>,
801 #[serde(skip_serializing_if = "Option::is_none")]
803 pub target_url: Option<String>,
804}
805
806#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
812pub struct RecrawlResponse {
813 pub task_id: String,
815}
816
817#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Default)]
819pub struct GetRecrawlTasksRequest {
820 #[serde(skip_serializing_if = "Option::is_none")]
822 pub offset: Option<i32>,
823 #[serde(skip_serializing_if = "Option::is_none")]
825 pub limit: Option<i32>,
826 #[serde(skip_serializing_if = "Option::is_none")]
828 pub date_from: Option<DateTime<Utc>>,
829 #[serde(skip_serializing_if = "Option::is_none")]
831 pub date_to: Option<DateTime<Utc>>,
832}
833
834#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
836pub struct RecrawlTasksResponse {
837 pub tasks: Vec<RecrawlTask>,
839}
840
841#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
843pub struct RecrawlTask {
844 pub task_id: String,
846 pub url: String,
848 #[serde(skip_serializing_if = "Option::is_none")]
850 pub added_time: Option<DateTime<Utc>>,
851 pub state: RecrawlTaskState,
853}
854
855#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq)]
857#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
858pub enum RecrawlTaskState {
859 InProgress,
861 Done,
863 Failed,
865}
866
867#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
869pub struct RecrawlQuotaResponse {
870 pub daily_quota: i32,
872 pub quota_remainder: i32,
874}
875
876#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq, Hash)]
882#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
883pub enum ApiInternalLinksBrokenIndicator {
884 SiteError,
886 DisallowedByUser,
888 UnsupportedByRobot,
890}
891
892#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
894pub struct BrokenLinksRequest {
895 #[serde(skip_serializing_if = "Option::is_none")]
897 pub indicator: Option<Vec<ApiInternalLinksBrokenIndicator>>,
898 #[serde(skip_serializing_if = "Option::is_none")]
900 pub offset: Option<i32>,
901 #[serde(skip_serializing_if = "Option::is_none")]
903 pub limit: Option<i32>,
904}
905
906#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
908pub struct BrokenLinksResponse {
909 pub count: i32,
911 pub links: Vec<BrokenLink>,
913}
914
915#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
917pub struct BrokenLink {
918 pub source_url: String,
920 pub destination_url: String,
922 pub discovery_date: NaiveDate,
924 pub source_last_access_date: NaiveDate,
926}
927
928#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Default)]
930pub struct BrokenLinkHistoryRequest {
931 #[serde(skip_serializing_if = "Option::is_none")]
933 pub date_from: Option<DateTime<Utc>>,
934 #[serde(skip_serializing_if = "Option::is_none")]
936 pub date_to: Option<DateTime<Utc>>,
937}
938
939#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
941pub struct BrokenLinkHistoryPoint {
942 pub date: DateTime<Utc>,
944 pub value: f64,
946}
947
948#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
950pub struct BrokenLinkHistoryResponse {
951 pub indicators: HashMap<ApiInternalLinksBrokenIndicator, Vec<BrokenLinkHistoryPoint>>,
953}
954
955#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
957pub struct ExternalLinksRequest {
958 #[serde(skip_serializing_if = "Option::is_none")]
960 pub offset: Option<i32>,
961 #[serde(skip_serializing_if = "Option::is_none")]
963 pub limit: Option<i32>,
964}
965
966#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
968pub struct ExternalLinksResponse {
969 pub count: i32,
971 pub links: Vec<ExternalLink>,
973}
974
975#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
977pub struct ExternalLink {
978 pub source_url: String,
980 pub destination_url: String,
982 pub discovery_date: NaiveDate,
984 pub source_last_access_date: NaiveDate,
986}
987
988#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq, Hash)]
990#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
991pub enum ApiExternalLinksIndicator {
992 LinksTotalCount,
994}
995
996#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
998pub struct ExternalLinksHistoryResponse {
999 pub indicators: HashMap<ApiExternalLinksIndicator, Vec<ExternalLinksHistoryPoint>>,
1001}
1002
1003#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
1005pub struct ExternalLinksHistoryPoint {
1006 pub date: DateTime<Utc>,
1008 pub value: f64,
1010}
1011
1012#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq, Hash)]
1018#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
1019pub enum ApiSiteProblemTypeEnum {
1020 ConnectFailed,
1023 DisallowedInRobots,
1025 DnsError,
1027 MainPageError,
1029 Threats,
1031
1032 InsignificantCgiParameter,
1035 SlowAvgResponseTime,
1037 SslCertificateError,
1039 #[serde(rename = "URL_ALERT_4XX")]
1041 UrlAlert4xx,
1042 #[serde(rename = "URL_ALERT_5XX")]
1044 UrlAlert5xx,
1045
1046 DisallowedUrlsAlert,
1049 DocumentsMissingDescription,
1051 DocumentsMissingTitle,
1053 DuplicateContentAttrs,
1055 DuplicatePages,
1057 ErrorInRobotsTxt,
1059 ErrorsInSitemaps,
1061 FaviconError,
1063 MainMirrorIsNotHttps,
1065 MainPageRedirects,
1067 NoMetrikaCounterBinding,
1069 NoMetrikaCounterCrawlEnabled,
1071 NoRobotsTxt,
1073 NoSitemaps,
1075 NoSitemapModifications,
1077 NonWorkingVideo,
1079 #[serde(rename = "SOFT_404")]
1081 Soft404,
1082 TooManyDomainsOnSearch,
1084 VideohostOfferFailed,
1086 VideohostOfferIsNeeded,
1088 VideohostOfferNeedPaper,
1090
1091 BigFaviconAbsent,
1094 FaviconProblem,
1096 NoMetrikaCounter,
1098 NoRegions,
1100 NotInSprav,
1102 NotMobileFriendly,
1104 VygodaPossibleActivation,
1106}
1107
1108#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq, Hash)]
1110#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
1111pub enum ApiSiteProblemState {
1112 Present,
1114 Absent,
1116 Undefined,
1118}
1119
1120#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
1122pub struct DiagnosticsResponse {
1123 pub problems: HashMap<ApiSiteProblemTypeEnum, SiteProblemInfo>,
1125}
1126
1127#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
1129pub struct SiteProblemInfo {
1130 pub severity: SiteProblemSeverityEnum,
1132 pub state: ApiSiteProblemState,
1134 pub last_state_update: Option<DateTime<Utc>>,
1136}
1137
1138#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
1144pub struct ImportantUrlsResponse {
1145 pub urls: Vec<ImportantUrl>,
1147}
1148
1149#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
1151pub struct ImportantUrl {
1152 pub url: String,
1154 #[serde(skip_serializing_if = "Option::is_none")]
1156 pub update_date: Option<DateTime<Utc>>,
1157 #[serde(default)]
1159 pub change_indicators: Vec<ApiImportantUrlChangeIndicator>,
1160 #[serde(skip_serializing_if = "Option::is_none")]
1162 pub indexing_status: Option<IndexingStatus>,
1163 #[serde(skip_serializing_if = "Option::is_none")]
1165 pub search_status: Option<SearchStatus>,
1166}
1167
1168#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
1170pub struct IndexingStatus {
1171 pub status: IndexingStatusEnum,
1173 #[serde(skip_serializing_if = "Option::is_none")]
1175 pub http_code: Option<i32>,
1176 pub access_date: DateTime<Utc>,
1178}
1179
1180#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
1182pub struct SearchStatus {
1183 pub title: String,
1185 #[serde(skip_serializing_if = "Option::is_none")]
1187 pub description: Option<String>,
1188 pub last_access: DateTime<Utc>,
1190 #[serde(skip_serializing_if = "Option::is_none")]
1192 pub excluded_url_status: Option<ApiExcludedUrlStatus>,
1193 #[serde(skip_serializing_if = "Option::is_none")]
1195 pub bad_http_status: Option<i32>,
1196 pub searchable: bool,
1198 #[serde(skip_serializing_if = "Option::is_none")]
1200 pub target_url: Option<String>,
1201}
1202
1203#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
1205pub struct ImportantUrlHistoryResponse {
1206 pub history: Vec<ImportantUrl>,
1208}