@a11ywatch/core/core/resolvers.d.ts

a11ywatch central API

export declare const resolvers: {
    Query: {
        issue: (_: any, { url, ...props }: {
            [x: string]: any;
            url: any;
        }, context: any) => Promise<any>;
        issues: (_: any, { url, ...props }: {
            [x: string]: any;
            url: any;
        }, context: any) => Promise<import("mongodb").WithId<import("bson").Document>[]>;
        history: (_: any, { ...props }: {
            [x: string]: any;
        }, context: any) => Promise<import("mongodb").WithId<import("bson").Document>[]>;
        pages: (_: any, { domain, ...props }: {
            [x: string]: any;
            domain: any;
        }, context: any) => Promise<import("mongodb").WithId<import("bson").Document>[] | (import("mongodb").Collection<import("bson").Document> | import("mongodb").WithId<import("bson").Document>[])[]>;
        website: (_: any, { url, ...props }: {
            [x: string]: any;
            url: any;
        }, context: any) => Promise<import("../types/schema").Website>;
        websites: (_: any, props: any, context: any) => Promise<import("mongodb").WithId<import("bson").Document>[] | (import("mongodb").Collection<import("bson").Document> | import("mongodb").WithId<import("bson").Document>[])[]>;
        user: (_: any, { id, password }: {
            id: any;
            password: any;
        }, ctx: any) => Promise<{
            emailConfirmed: boolean;
            keyid: number;
            activeSubscription: boolean;
            loggedIn: boolean;
            accountType: string;
            passwordRequired: boolean;
            pageSpeedApiKey?: string;
            __typename?: "User";
            id?: number;
            email?: string;
            password?: string;
            jwt?: string;
            salt?: string;
            alertEnabled?: boolean;
            lastAlertSent?: number;
            lastAlertDateStamp?: number;
            role?: number;
            emailFilteredDates?: number[];
            websites?: import("../types/schema").Website[];
            profileVisible?: boolean;
            history?: import("../types/schema").History[];
            scanInfo?: import("../types/schema").ScanInformation;
            analytics?: import("../types/schema").Analytic[];
            paymentSubscription?: Stripe.subscriptions.ISubscription;
            websiteLimit?: number;
            lastLoginDate?: string;
            downAlerts?: import("../types/schema").Website[];
            emailExpDate?: string;
            resetCode?: string;
            stripeID?: string;
            usageAnchorDate?: number | Date;
        }>;
        pagespeed: (_: any, { url, pageUrl, ...props }: {
            [x: string]: any;
            url: any;
            pageUrl: any;
        }, context: any) => Promise<any>;
    };
    Mutation: {
        updateUser: (_: any, { email, password, newPassword }: {
            email: any;
            password: any;
            newPassword: any;
        }, context: any) => Promise<any>;
        login: typeof import("./graph/mutations").login;
        register: typeof import("./graph/mutations").register;
        logout: typeof import("./graph/mutations").logout;
        addWebsite: (_: any, { url, customHeaders, pageInsights, mobile, ua, standard, actions, robots, subdomains, tld, ignore, rules, runners, proxy, sitemap, monitoringEnabled, ...props }: {
            [x: string]: any;
            url: any;
            customHeaders: any;
            pageInsights: any;
            mobile: any;
            ua: any;
            standard: any;
            actions: any;
            robots: any;
            subdomains: any;
            tld: any;
            ignore: any;
            rules: any;
            runners: any;
            proxy: any;
            sitemap: any;
            monitoringEnabled: any;
        }, context: any) => Promise<{
            website: {
                actions: any;
                userId: any;
                url: string;
                domain: string;
                pageInsights: boolean;
                pageHeaders: any[];
                pageLoadTime: {
                    duration: number;
                    durationFormated: string;
                    color: string;
                };
                lastScanDate: string;
                online: boolean;
                ua: string;
                mobile: boolean;
                standard: string;
                actionsEnabled: boolean;
                monitoringEnabled: boolean;
                robots: boolean;
                subdomains: boolean;
                tld: boolean;
                order: number;
                verified: boolean;
                verificationCode: string;
                ignore: any[];
                rules: any[];
                runners: any[];
                proxy: string;
            };
            code: number;
            success: boolean;
            message: string;
        }>;
        crawlWebsite: (_: any, { url }: {
            url: any;
        }, context: any) => Promise<{
            website: any;
            code: number;
            success: boolean;
            message: string;
        }>;
        scanWebsite: (parent: any, args: any, context: any, info: any) => Promise<any>;
        removeWebsite: (_: any, { url, deleteMany }: {
            url: any;
            deleteMany?: boolean;
        }, context: any) => Promise<{
            code: number;
            success: boolean;
            message: string;
            website?: undefined;
        } | {
            website: import("../types/schema").Website;
            code: number;
            success: boolean;
            message: string;
        } | {
            url: string;
            id: number;
            code: number;
            success: boolean;
            message: string;
            website?: undefined;
        } | {
            url: string;
            id: number;
            website: import("../types/schema").Website;
            code: number;
            success: boolean;
            message: string;
        }>;
        updateWebsite: (_: any, { userId, url, customHeaders, pageInsights, mobile, standard, ua, robots, subdomains, tld, ignore, rules, runners, proxy, sitemap, monitoringEnabled, }: {
            userId: any;
            url: any;
            customHeaders: any;
            pageInsights: any;
            mobile: any;
            standard: any;
            ua: any;
            robots: any;
            subdomains: any;
            tld: any;
            ignore: any;
            rules: any;
            runners: any;
            proxy: any;
            sitemap: any;
            monitoringEnabled: any;
        }, context: any) => Promise<{
            website: {
                actions: Record<string, unknown>[];
                actionsEnabled: boolean;
                robots: boolean;
                pageHeaders: import("../types/schema").PageHeaders[];
                pageInsights: boolean;
                mobile: boolean;
                standard: string;
                ua: string;
                subdomains: boolean;
                tld: boolean;
                ignore: string[];
                rules: string[];
                runners: string[];
                proxy: string;
                sitemap: boolean;
                monitoringEnabled: boolean;
                __typename?: "Website";
                id?: string;
                url?: string;
                user?: import("../types/schema").User;
                userId?: number;
                domain?: string;
                pageLoadTime?: import("../types/schema").PageLoadTimeMeta;
                issuesInfo?: import("../types/schema").IssueMeta;
                pages?: import("../types/schema").Pages[];
                lastScanDate?: number | Date;
                documentTitle?: string;
                cdn?: string;
                online?: boolean;
                timestamp?: string;
                insight?: import("../types/schema").PageInsights;
                verified?: boolean;
            };
            code: number;
            success: boolean;
            message: string;
        }>;
        forgotPassword: (_: any, { email }: {
            email: any;
        }, _context: any) => Promise<any>;
        confirmEmail: (_: any, { email }: {
            email: any;
        }, context: any) => Promise<any>;
        resetPassword: (_: any, { email, resetCode }: {
            email: any;
            resetCode: any;
        }, _context: any) => Promise<any>;
        toggleAlert: (_: any, { alertEnabled }: {
            alertEnabled: any;
        }, context: any) => Promise<Partial<import("../types/types").User>>;
        sortWebsites: (_: any, { order }: {
            order: any;
        }, context: any) => Promise<{
            code: number;
            success: boolean;
            message: string;
        }>;
        setPageSpeedKey: (_: any, { pageSpeedApiKey }: {
            pageSpeedApiKey: any;
        }, context: any) => Promise<any>;
        addPaymentSubscription: (_: any, { stripeToken, yearly }: {
            stripeToken: any;
            yearly: any;
        }, context: any) => Promise<any>;
        cancelSubscription: (_: any, {}: {}, context: any) => Promise<any>;
        filterEmailDates: (_: any, { emailFilteredDates, morning, ...props }: {
            [x: string]: any;
            emailFilteredDates: any;
            morning: any;
        }, context: any) => Promise<any>;
    };
    Subscription: {
        emailVerified: {
            subscribe: import("graphql-subscriptions").ResolverFn;
        };
        issueAdded: {
            subscribe: import("graphql-subscriptions").ResolverFn;
        };
        websiteAdded: {
            subscribe: import("graphql-subscriptions").ResolverFn;
        };
        websiteRemoved: {
            subscribe: import("graphql-subscriptions").ResolverFn;
        };
        crawlComplete: {
            subscribe: import("graphql-subscriptions").ResolverFn;
        };
        lighthouseResult: {
            subscribe: import("graphql-subscriptions").ResolverFn;
        };
    };
    User: {
        history: ({ id, keyid }: {
            id: any;
            keyid: any;
        }) => Promise<import("mongodb").WithId<import("bson").Document>[]>;
        analytics: ({ id, keyid }: {
            id: any;
            keyid: any;
        }) => Promise<import("mongodb").WithId<import("bson").Document>[]>;
        websites: ({ id, keyid }: {
            id: any;
            keyid: any;
        }, params: any) => Promise<import("../types/schema").Website[] | [import("../types/schema").Website[], any]>;
        invoice: ({ id, keyid }: {
            id: any;
            keyid: any;
        }, params: any) => Promise<any>;
    };
    Analytic: {};
    Website: {
        user: ({ userId }: {
            userId: any;
        }) => Promise<import("../types/types").User>;
        issues: ({ userId, url, pageUrl }: {
            userId: any;
            url: any;
            pageUrl: any;
        }, params: any) => Promise<import("../types/schema").Issue[]>;
        analytics: ({ userId, domain }: {
            userId: any;
            domain: any;
        }, params: any) => Promise<import("../types/schema").Analytic[] | [import("../types/schema").Analytic[], import("mongodb").Collection<import("bson").Document>]>;
        pages: ({ userId, url, domain, insights }: {
            userId: any;
            url: any;
            domain: any;
            insights?: boolean;
        }, params: any) => Promise<import("mongodb").WithId<import("bson").Document>[] | (import("mongodb").Collection<import("bson").Document> | import("mongodb").WithId<import("bson").Document>[])[]>;
        actions: ({ userId, domain }: {
            userId: any;
            domain: any;
        }, params: any) => Promise<any[]>;
        insight: ({ userId, domain, url }: {
            userId: any;
            domain: any;
            url: any;
        }, _params: any) => Promise<import("mongodb").WithId<import("bson").Document>>;
    };
    Issue: {};
    Pages: {
        issues: ({ userId, url }: {
            userId: any;
            url: any;
        }) => Promise<any>;
        issuesInfo: ({ userId, url }: {
            userId: any;
            url: any;
        }, _params: any) => Promise<any>;
    };
    History: {
        issues: ({ userId, url }: {
            userId: any;
            url: any;
        }, { filter }: {
            filter: any;
        }) => Promise<import("mongodb").WithId<import("bson").Document>[]>;
        pages: ({ userId, url, domain }: {
            userId: any;
            url: any;
            domain: any;
        }) => Promise<import("mongodb").WithId<import("bson").Document>[] | (import("mongodb").Collection<import("bson").Document> | import("mongodb").WithId<import("bson").Document>[])[]>;
    };
};