import type { MoteurClientConfig } from '../types.js';
/** Full SDK for JWT (or bearer): auth, projects, all `/projects/:id/...` resources, `/blueprints`, `instance` (deployment maintenance), optional global `/activity`. */
export declare function createMoteurAdminClient(config: MoteurClientConfig): {
    auth: {
        login(username: string, password: string): Promise<import("../types.js").LoginResult>;
        me(): Promise<{
            user: import("@moteurio/types").User;
        }>;
        refresh(): Promise<{
            token: string;
        }>;
        providers(): Promise<{
            providers: {
                id: string;
                label: string;
            }[];
        }>;
    };
    projects: {
        list(): Promise<{
            projects: import("@moteurio/types").ProjectSchema[];
        }>;
        get(projectId: string): Promise<{
            project: import("@moteurio/types").ProjectSchema;
        }>;
        create(body: Record<string, unknown>): Promise<{
            project: import("@moteurio/types").ProjectSchema;
        }>;
        update(projectId: string, body: Record<string, unknown>): Promise<{
            project: import("@moteurio/types").ProjectSchema;
        }>;
        delete(projectId: string): Promise<void>;
        users(projectId: string): Promise<{
            users: import("@moteurio/types").ProjectMemberUser[];
        }>;
        patchProjectUser(projectId: string, userId: string, body: {
            name?: string;
            email?: string;
            isActive?: boolean;
            roles?: string[];
            avatar?: string;
        }): Promise<{
            user: import("@moteurio/types").ProjectMemberUser;
        }>;
        activity: {
            list(projectId: string, params?: {
                limit?: number;
                before?: string;
            }): Promise<import("@moteurio/types").ActivityLogPage>;
        };
        branches: {
            list(projectId: string): Promise<{
                branches: string[];
                current?: string;
            }>;
            create(projectId: string, name: string, from?: string): Promise<{
                branch: string;
                from: string;
            }>;
            switch(projectId: string, branch: string): Promise<{
                branch: string;
            }>;
            merge(projectId: string, sourceBranch: string): Promise<{
                merged: string;
            }>;
        };
        radar: {
            get(projectId: string, options?: {
                fullScan?: boolean;
                severity?: string;
                model?: string;
                locale?: string;
                ruleId?: string;
            }): Promise<import("@moteurio/types").RadarReport>;
        };
        comments: {
            list(projectId: string, params: {
                resourceType: string;
                resourceId: string;
                includeResolved?: boolean;
                fieldPath?: string;
            }): Promise<{
                comments: import("@moteurio/types").Comment[];
            }>;
            add(projectId: string, body: {
                resourceType: string;
                resourceId: string;
                body: string;
                fieldPath?: string;
                blockId?: string;
                parentId?: string;
            }): Promise<{
                comment: import("@moteurio/types").Comment;
            }>;
            resolve(projectId: string, commentId: string): Promise<{
                comment: import("@moteurio/types").Comment;
            }>;
            delete(projectId: string, commentId: string): Promise<void>;
            edit(projectId: string, commentId: string, body: {
                body: string;
            }): Promise<{
                comment: import("@moteurio/types").Comment;
            }>;
        };
    };
    models: {
        list(projectId: string): Promise<{
            models: import("@moteurio/types").ModelSchema[];
        }>;
        get(projectId: string, modelId: string): Promise<{
            model: import("@moteurio/types").ModelSchema;
        }>;
        create(projectId: string, body: Record<string, unknown>): Promise<{
            model: import("@moteurio/types").ModelSchema;
        }>;
        update(projectId: string, modelId: string, body: Record<string, unknown>): Promise<{
            model: import("@moteurio/types").ModelSchema;
        }>;
        delete(projectId: string, modelId: string): Promise<void>;
    };
    entries: {
        list(projectId: string, modelId: string, params?: import("../project/entries.js").EntryListParams): Promise<import("../project/entries.js").EntryListResult>;
        get(projectId: string, modelId: string, entryId: string): Promise<{
            entry: import("@moteurio/types").Entry;
        }>;
        create(projectId: string, modelId: string, body: Record<string, unknown>): Promise<{
            entry: import("@moteurio/types").Entry;
        }>;
        update(projectId: string, modelId: string, entryId: string, body: Record<string, unknown>): Promise<{
            entry: import("@moteurio/types").Entry;
        }>;
        delete(projectId: string, modelId: string, entryId: string): Promise<void>;
        status(projectId: string, modelId: string, entryId: string, status: string): Promise<{
            entry: Record<string, unknown>;
        }>;
        submitReview(projectId: string, modelId: string, entryId: string): Promise<{
            entry: Record<string, unknown>;
        }>;
    };
    pages: {
        list(projectId: string): Promise<{
            pages: {
                [x: string]: unknown;
            }[];
        }>;
        get(projectId: string, pageId: string): Promise<{
            page: {
                [x: string]: unknown;
            };
        }>;
        getBySlug(projectId: string, slug: string): Promise<{
            page: {
                [x: string]: unknown;
            };
        }>;
        create(projectId: string, body: Record<string, unknown>): Promise<{
            page: {
                [x: string]: unknown;
            };
        }>;
        update(projectId: string, pageId: string, body: Record<string, unknown>): Promise<{
            page: {
                [x: string]: unknown;
            };
        }>;
        reorder(projectId: string, moves: import("../project/pages.js").PageMove[]): Promise<{
            pages: {
                [x: string]: unknown;
            }[];
        }>;
        delete(projectId: string, pageId: string): Promise<void>;
        status(projectId: string, pageId: string, status: string): Promise<{
            page: {
                [x: string]: unknown;
            };
        }>;
        submitReview(projectId: string, pageId: string): Promise<Record<string, unknown>>;
    };
    templates: {
        list(projectId: string): Promise<{
            templates: Record<string, unknown>[];
        }>;
        get(projectId: string, templateId: string): Promise<{
            template: Record<string, unknown>;
        }>;
        create(projectId: string, body: Record<string, unknown>): Promise<{
            template: Record<string, unknown>;
        }>;
        update(projectId: string, templateId: string, body: Record<string, unknown>): Promise<{
            template: Record<string, unknown>;
        }>;
        delete(projectId: string, templateId: string): Promise<void>;
    };
    layouts: {
        list(projectId: string): Promise<{
            layouts: Record<string, unknown>[];
        }>;
        get(projectId: string, layoutId: string): Promise<{
            layout: Record<string, unknown>;
        }>;
        create(projectId: string, body: Record<string, unknown>): Promise<{
            layout: Record<string, unknown>;
        }>;
        update(projectId: string, layoutId: string, body: Record<string, unknown>): Promise<{
            layout: Record<string, unknown>;
        }>;
        delete(projectId: string, layoutId: string): Promise<void>;
    };
    structures: {
        list(projectId: string): Promise<{
            structures: Record<string, unknown>[];
        }>;
        get(projectId: string, structureId: string): Promise<{
            structure: Record<string, unknown>;
        }>;
        create(projectId: string, body: Record<string, unknown>): Promise<{
            structure: Record<string, unknown>;
        }>;
        update(projectId: string, structureId: string, body: Record<string, unknown>): Promise<{
            structure: Record<string, unknown>;
        }>;
        delete(projectId: string, structureId: string): Promise<void>;
    };
    collections: {
        list(projectId: string): Promise<{
            collections: Record<string, unknown>[];
        }>;
        get(projectId: string, collectionId: string): Promise<{
            collection: Record<string, unknown>;
        }>;
        create(projectId: string, body: Record<string, unknown>): Promise<{
            collection: Record<string, unknown>;
        }>;
        update(projectId: string, collectionId: string, body: Record<string, unknown>): Promise<{
            collection: Record<string, unknown>;
        }>;
        delete(projectId: string, collectionId: string): Promise<void>;
    };
    forms: {
        list(projectId: string): Promise<{
            forms: Record<string, unknown>[];
        }>;
        get(projectId: string, formId: string): Promise<{
            form: Record<string, unknown>;
        }>;
        create(projectId: string, body: Record<string, unknown>): Promise<{
            form: Record<string, unknown>;
        }>;
        update(projectId: string, formId: string, body: Record<string, unknown>): Promise<{
            form: Record<string, unknown>;
        }>;
        delete(projectId: string, formId: string): Promise<void>;
    };
    submissions: {
        list(projectId: string, formId: string, params?: import("../project/submissions.js").SubmissionListParams): Promise<import("../project/submissions.js").SubmissionListResult>;
        get(projectId: string, formId: string, submissionId: string): Promise<{
            submission: Record<string, unknown>;
        }>;
        update(projectId: string, formId: string, submissionId: string, patch: {
            read?: boolean;
            spam?: boolean;
        }): Promise<{
            submission: Record<string, unknown>;
        }>;
        export(projectId: string, formId: string, format?: "csv" | "json"): Promise<string>;
        delete(projectId: string, formId: string, submissionId: string): Promise<void>;
    };
    navigations: {
        list(projectId: string): Promise<{
            navigations: Record<string, unknown>[];
        }>;
        get(projectId: string, navigationId: string): Promise<{
            navigation: Record<string, unknown>;
        }>;
        create(projectId: string, body: Record<string, unknown>): Promise<{
            navigation: Record<string, unknown>;
        }>;
        update(projectId: string, navigationId: string, body: Record<string, unknown>): Promise<{
            navigation: Record<string, unknown>;
        }>;
        delete(projectId: string, navigationId: string): Promise<void>;
    };
    webhooks: {
        list(projectId: string): Promise<{
            webhooks: Record<string, unknown>[];
        }>;
        get(projectId: string, webhookId: string): Promise<{
            webhook: Record<string, unknown>;
        }>;
        create(projectId: string, body: Record<string, unknown>): Promise<{
            webhook: Record<string, unknown>;
        }>;
        update(projectId: string, webhookId: string, body: Record<string, unknown>): Promise<{
            webhook: Record<string, unknown>;
        }>;
        delete(projectId: string, webhookId: string): Promise<void>;
        test(projectId: string, webhookId: string): Promise<{
            ok: boolean;
            status?: number;
        }>;
    };
    schedules: {
        list(projectId: string, options?: import("@moteurio/types").ListSchedulesOptions): Promise<{
            schedules: import("@moteurio/types").Schedule[];
        }>;
        get(projectId: string, scheduleId: string): Promise<import("@moteurio/types").Schedule>;
        create(projectId: string, body: import("@moteurio/types").CreateScheduleInput): Promise<import("@moteurio/types").Schedule>;
        cancel(projectId: string, scheduleId: string): Promise<import("@moteurio/types").Schedule>;
        delete(projectId: string, scheduleId: string): Promise<void>;
    };
    assets: {
        list(projectId: string, params?: {
            type?: string;
            folder?: string;
            search?: string;
            hash?: string;
        }): Promise<Record<string, unknown>[]>;
        page(projectId: string, params: {
            limit: number;
            offset?: number;
            type?: string;
            folder?: string;
            search?: string;
            facets?: boolean;
        }): Promise<import("../project/assets.js").AssetPage>;
        get(projectId: string, id: string): Promise<Record<string, unknown>>;
        upload(projectId: string, formData: FormData): Promise<Record<string, unknown>>;
        update(projectId: string, id: string, body: Record<string, unknown>): Promise<Record<string, unknown>>;
        replace(projectId: string, id: string, formData: FormData): Promise<Record<string, unknown>>;
        checkVideo(projectId: string, id: string): Promise<Record<string, unknown>>;
        retryVideo(projectId: string, id: string): Promise<Record<string, unknown>>;
        delete(projectId: string, id: string): Promise<void>;
        bin(projectId: string): Promise<Record<string, unknown>[]>;
        restore(projectId: string, id: string): Promise<Record<string, unknown>>;
        deleteForever(projectId: string, id: string): Promise<void>;
        emptyBin(projectId: string): Promise<{
            deleted: number;
        }>;
        regenerate(projectId: string, assetIds?: string[], options?: {
            background?: boolean;
        }): Promise<{
            processed?: number;
            errors?: number;
            queued?: number;
        }>;
        usageCounts(projectId: string): Promise<{
            counts: Record<string, number>;
        }>;
        usage(projectId: string, id: string): Promise<{
            usages: import("../project/assets.js").AssetUsage[];
        }>;
        move(projectId: string, id: string, folder: string): Promise<Record<string, unknown>>;
        batch(projectId: string, batch: {
            action: "bin" | "restore";
            ids: string[];
        } | {
            action: "move";
            ids: string[];
            folder: string;
        } | {
            action: "update";
            changes: {
                id: string;
                patch: Record<string, unknown>;
            }[];
        }): Promise<{
            assets: Record<string, unknown>[];
        }>;
    };
    assetConfig: {
        get(projectId: string): Promise<Record<string, unknown>>;
        update(projectId: string, body: Record<string, unknown>): Promise<Record<string, unknown>>;
    };
    mediaSettings: {
        get(projectId: string): Promise<import("../project/mediaSettings.js").MediaSettings>;
        update(projectId: string, body: import("../project/mediaSettings.js").MediaSettingsUpdate): Promise<Pick<import("../project/mediaSettings.js").MediaSettings, "assetConfig" | "videoProviders">>;
        checkStorage(projectId: string, body: import("../project/mediaSettings.js").StorageSettings): Promise<{
            ok: boolean;
            error?: string;
        }>;
        moveStorage(projectId: string, body: import("../project/mediaSettings.js").StorageSettings): Promise<{
            moved: number;
        }>;
        moveVideos(projectId: string, body?: {
            removeFromOld?: boolean;
        }): Promise<{
            to: string;
            moving: number;
            staying: number;
        }>;
        forgetVideoHost(projectId: string, host: string): Promise<{
            videoProviders?: import("@moteurio/types").VideoProvidersConfig;
        }>;
    };
    blocks: {
        list(projectId: string): Promise<Record<string, unknown>>;
        get(projectId: string, id: string): Promise<Record<string, unknown>>;
        create(projectId: string, body: Record<string, unknown>): Promise<Record<string, unknown>>;
        update(projectId: string, id: string, body: Record<string, unknown>): Promise<Record<string, unknown>>;
        delete(projectId: string, id: string): Promise<void>;
    };
    apiKeys: {
        list(projectId: string): Promise<import("../project/apiKeys.js").ProjectApiKeyMeta[]>;
        create(projectId: string, body?: import("../project/apiKeys.js").ProjectApiKeyCreateBody): Promise<import("../project/apiKeys.js").ProjectApiKeyCreateResponse>;
        rotate(projectId: string, keyId: string): Promise<import("../project/apiKeys.js").ProjectApiKeyCreateResponse>;
        revoke(projectId: string, keyId: string): Promise<void>;
        patch(projectId: string, keyId: string, body: import("../project/apiKeys.js").ProjectApiKeyPatchBody): Promise<import("../project/apiKeys.js").ProjectApiKeyMeta>;
    };
    instance: {
        usage: () => Promise<Record<string, unknown>>;
        seed: {
            run(options?: {
                force?: boolean;
            }): Promise<{
                copied: string[];
                skipped: string[];
            }>;
        };
        migrateProvider: (body: {
            toProvider: string;
            fromProvider?: string;
            projectIds: string[];
            removeFromOld?: boolean;
        }) => Promise<Record<string, unknown>>;
    };
    blueprints: {
        list(kind: "model" | "project" | "structure" | "template"): Promise<{
            blueprints: Record<string, unknown>[];
        }>;
        get(kind: "model" | "project" | "structure" | "template", blueprintId: string): Promise<Record<string, unknown>>;
        create(kind: "model" | "project" | "structure" | "template", body: Record<string, unknown>): Promise<Record<string, unknown>>;
        update(kind: "model" | "project" | "structure" | "template", blueprintId: string, body: Record<string, unknown>): Promise<Record<string, unknown>>;
        delete(kind: "model" | "project" | "structure" | "template", blueprintId: string): Promise<void>;
    };
    activity: {
        list(params?: {
            limit?: number;
            before?: string;
        }): Promise<import("@moteurio/types").ActivityLogPage>;
    };
    ai: {
        helpers(projectId: string): Promise<import("./ai.js").AiHelpers>;
        write(params: {
            projectId: string;
            action: import("./ai.js").WritingAction;
            field: {
                key: string;
                label?: string;
                type?: string;
            };
            value?: string;
            body?: string;
            locale?: string;
            modelId?: string;
            entryId?: string;
        }): Promise<import("./ai.js").AiTextResult>;
        translateField(params: {
            projectId: string;
            value: string;
            from: string;
            to: string;
            field?: {
                key: string;
                type?: string;
            };
            modelId?: string;
            entryId?: string;
        }): Promise<import("./ai.js").AiTextResult>;
        analyseImage(params: {
            projectId: string;
            assetId: string;
            locale?: string;
            otherAlt?: string;
        }): Promise<{
            alt: string;
            caption: string;
            creditsUsed: number;
            creditsRemaining: number;
        }>;
        generateAudio(params: {
            projectId: string;
            prompt: string;
            voice?: string;
            entryId?: string;
            fieldPath?: string;
        }): Promise<import("./ai.js").AiAudioResult>;
        generateModel3d(params: {
            projectId: string;
            prompt: string;
            textured?: boolean;
            format?: "glb" | "usdz";
            entryId?: string;
            fieldPath?: string;
        }): Promise<import("./ai.js").AiModel3dResult>;
        saveGeneratedModel(params: {
            projectId: string;
            url: string;
            format?: "glb" | "usdz";
            thumbnailUrl?: string;
            prompt?: string;
            provider?: string;
            title?: string;
            entryId?: string;
            fieldPath?: string;
        }): Promise<{
            asset: Record<string, unknown> & {
                id: string;
                url: string;
            };
            poster?: Record<string, unknown> & {
                id: string;
                url: string;
            };
        }>;
        activity(projectId: string, params?: {
            limit?: number;
            before?: string;
        }): Promise<import("@moteurio/types").AiAuditLogPage>;
        generateEntry(params: import("./ai.js").GenerateEntryParams): Promise<import("./ai.js").GenerateEntryResult>;
        projectOverview(projectId: string): Promise<import("./ai.js").AiProjectOverview>;
    };
    operator: {
        summary(): Promise<Record<string, unknown>>;
        projects: {
            list(): Promise<{
                projects: Record<string, unknown>[];
            }>;
            setPlugins(projectId: string, plugins: string[] | null): Promise<{
                project: Record<string, unknown>;
            }>;
        };
        users: {
            list(): Promise<{
                users: Record<string, unknown>[];
            }>;
            update(userId: string, body: Record<string, unknown>): Promise<{
                user: Record<string, unknown>;
            }>;
        };
        plugins: {
            list(): Promise<{
                plugins: Record<string, unknown>[];
            }>;
            set(pluginId: string, on: boolean | null): Promise<{
                plugin: Record<string, unknown>;
            }>;
        };
        schemas: {
            list(kind: "structures" | "blocks"): Promise<{
                items: Record<string, unknown>[];
            }>;
            save(kind: "structures" | "blocks", name: string, schema: Record<string, unknown>): Promise<{
                item: Record<string, unknown>;
            }>;
            delete(kind: "structures" | "blocks", name: string): Promise<void>;
        };
    };
    forProject: (projectId: string) => {
        projectId: string;
        project: {
            get: () => Promise<{
                project: import("@moteurio/types").ProjectSchema;
            }>;
            update: (body: Record<string, unknown>) => Promise<{
                project: import("@moteurio/types").ProjectSchema;
            }>;
            delete: () => Promise<void>;
            users: () => Promise<{
                users: import("@moteurio/types").ProjectMemberUser[];
            }>;
        };
        branches: {
            list: () => Promise<{
                branches: string[];
                current?: string;
            }>;
            create: (name: string, from?: string) => Promise<{
                branch: string;
                from: string;
            }>;
            switch: (branch: string) => Promise<{
                branch: string;
            }>;
            merge: (sourceBranch: string) => Promise<{
                merged: string;
            }>;
        };
        radar: {
            get: (options?: {
                fullScan?: boolean;
                severity?: string;
                model?: string;
                locale?: string;
                ruleId?: string;
            }) => Promise<import("@moteurio/types").RadarReport>;
        };
        comments: {
            list: (params: {
                resourceType: string;
                resourceId: string;
                includeResolved?: boolean;
                fieldPath?: string;
            }) => Promise<{
                comments: import("@moteurio/types").Comment[];
            }>;
            add: (body: {
                resourceType: string;
                resourceId: string;
                body: string;
                fieldPath?: string;
                blockId?: string;
                parentId?: string;
            }) => Promise<{
                comment: import("@moteurio/types").Comment;
            }>;
            resolve: (commentId: string) => Promise<{
                comment: import("@moteurio/types").Comment;
            }>;
            delete: (commentId: string) => Promise<void>;
            edit: (commentId: string, body: {
                body: string;
            }) => Promise<{
                comment: import("@moteurio/types").Comment;
            }>;
        };
        activity: {
            list: (params?: {
                limit?: number;
                before?: string;
            }) => Promise<import("@moteurio/types").ActivityLogPage>;
        };
        models: {
            list: () => Promise<{
                models: import("@moteurio/types").ModelSchema[];
            }>;
            get: (modelId: string) => Promise<{
                model: import("@moteurio/types").ModelSchema;
            }>;
            create: (body: Record<string, unknown>) => Promise<{
                model: import("@moteurio/types").ModelSchema;
            }>;
            update: (modelId: string, body: Record<string, unknown>) => Promise<{
                model: import("@moteurio/types").ModelSchema;
            }>;
            delete: (modelId: string) => Promise<void>;
        };
        entries: {
            list: (modelId: string, params?: Parameters<(projectId: string, modelId: string, params?: import("../project/entries.js").EntryListParams) => Promise<import("../project/entries.js").EntryListResult>>[2]) => Promise<import("../project/entries.js").EntryListResult>;
            get: (modelId: string, entryId: string) => Promise<{
                entry: import("@moteurio/types").Entry;
            }>;
            create: (modelId: string, body: Record<string, unknown>) => Promise<{
                entry: import("@moteurio/types").Entry;
            }>;
            update: (modelId: string, entryId: string, body: Record<string, unknown>) => Promise<{
                entry: import("@moteurio/types").Entry;
            }>;
            delete: (modelId: string, entryId: string) => Promise<void>;
            status: (modelId: string, entryId: string, status: string) => Promise<{
                entry: Record<string, unknown>;
            }>;
            submitReview: (modelId: string, entryId: string) => Promise<{
                entry: Record<string, unknown>;
            }>;
        };
        pages: {
            list: () => Promise<{
                pages: {
                    [x: string]: unknown;
                }[];
            }>;
            get: (pageId: string) => Promise<{
                page: {
                    [x: string]: unknown;
                };
            }>;
            getBySlug: (slug: string) => Promise<{
                page: {
                    [x: string]: unknown;
                };
            }>;
            create: (body: Record<string, unknown>) => Promise<{
                page: {
                    [x: string]: unknown;
                };
            }>;
            update: (pageId: string, body: Record<string, unknown>) => Promise<{
                page: {
                    [x: string]: unknown;
                };
            }>;
            reorder: (moves: import("../project/pages.js").PageMove[]) => Promise<{
                pages: {
                    [x: string]: unknown;
                }[];
            }>;
            delete: (pageId: string) => Promise<void>;
            status: (pageId: string, status: string) => Promise<{
                page: {
                    [x: string]: unknown;
                };
            }>;
            submitReview: (pageId: string) => Promise<Record<string, unknown>>;
        };
        templates: {
            list: () => Promise<{
                templates: Record<string, unknown>[];
            }>;
            get: (templateId: string) => Promise<{
                template: Record<string, unknown>;
            }>;
            create: (body: Record<string, unknown>) => Promise<{
                template: Record<string, unknown>;
            }>;
            update: (templateId: string, body: Record<string, unknown>) => Promise<{
                template: Record<string, unknown>;
            }>;
            delete: (templateId: string) => Promise<void>;
        };
        layouts: {
            list: () => Promise<{
                layouts: Record<string, unknown>[];
            }>;
            get: (layoutId: string) => Promise<{
                layout: Record<string, unknown>;
            }>;
            create: (body: Record<string, unknown>) => Promise<{
                layout: Record<string, unknown>;
            }>;
            update: (layoutId: string, body: Record<string, unknown>) => Promise<{
                layout: Record<string, unknown>;
            }>;
            delete: (layoutId: string) => Promise<void>;
        };
        structures: {
            list: () => Promise<{
                structures: Record<string, unknown>[];
            }>;
            get: (structureId: string) => Promise<{
                structure: Record<string, unknown>;
            }>;
            create: (body: Record<string, unknown>) => Promise<{
                structure: Record<string, unknown>;
            }>;
            update: (structureId: string, body: Record<string, unknown>) => Promise<{
                structure: Record<string, unknown>;
            }>;
            delete: (structureId: string) => Promise<void>;
        };
        collections: {
            list: () => Promise<{
                collections: Record<string, unknown>[];
            }>;
            get: (collectionId: string) => Promise<{
                collection: Record<string, unknown>;
            }>;
            create: (body: Record<string, unknown>) => Promise<{
                collection: Record<string, unknown>;
            }>;
            update: (collectionId: string, body: Record<string, unknown>) => Promise<{
                collection: Record<string, unknown>;
            }>;
            delete: (collectionId: string) => Promise<void>;
        };
        forms: {
            list: () => Promise<{
                forms: Record<string, unknown>[];
            }>;
            get: (formId: string) => Promise<{
                form: Record<string, unknown>;
            }>;
            create: (body: Record<string, unknown>) => Promise<{
                form: Record<string, unknown>;
            }>;
            update: (formId: string, body: Record<string, unknown>) => Promise<{
                form: Record<string, unknown>;
            }>;
            delete: (formId: string) => Promise<void>;
        };
        submissions: {
            list: (formId: string, params?: import("../project/submissions.js").SubmissionListParams) => Promise<import("../project/submissions.js").SubmissionListResult>;
            get: (formId: string, submissionId: string) => Promise<{
                submission: Record<string, unknown>;
            }>;
            update: (formId: string, submissionId: string, patch: {
                read?: boolean;
                spam?: boolean;
            }) => Promise<{
                submission: Record<string, unknown>;
            }>;
            export: (formId: string, format?: "csv" | "json") => Promise<string>;
            delete: (formId: string, submissionId: string) => Promise<void>;
        };
        navigations: {
            list: () => Promise<{
                navigations: Record<string, unknown>[];
            }>;
            get: (navigationId: string) => Promise<{
                navigation: Record<string, unknown>;
            }>;
            create: (body: Record<string, unknown>) => Promise<{
                navigation: Record<string, unknown>;
            }>;
            update: (navigationId: string, body: Record<string, unknown>) => Promise<{
                navigation: Record<string, unknown>;
            }>;
            delete: (navigationId: string) => Promise<void>;
        };
        webhooks: {
            list: () => Promise<{
                webhooks: Record<string, unknown>[];
            }>;
            get: (webhookId: string) => Promise<{
                webhook: Record<string, unknown>;
            }>;
            create: (body: Record<string, unknown>) => Promise<{
                webhook: Record<string, unknown>;
            }>;
            update: (webhookId: string, body: Record<string, unknown>) => Promise<{
                webhook: Record<string, unknown>;
            }>;
            delete: (webhookId: string) => Promise<void>;
            test: (webhookId: string) => Promise<{
                ok: boolean;
                status?: number;
            }>;
        };
        schedules: {
            list: (options?: import("@moteurio/types").ListSchedulesOptions) => Promise<{
                schedules: import("@moteurio/types").Schedule[];
            }>;
            get: (scheduleId: string) => Promise<import("@moteurio/types").Schedule>;
            create: (body: import("@moteurio/types").CreateScheduleInput) => Promise<import("@moteurio/types").Schedule>;
            cancel: (scheduleId: string) => Promise<import("@moteurio/types").Schedule>;
            delete: (scheduleId: string) => Promise<void>;
        };
        assets: {
            list: (params?: {
                type?: string;
                folder?: string;
                search?: string;
                hash?: string;
            }) => Promise<Record<string, unknown>[]>;
            get: (id: string) => Promise<Record<string, unknown>>;
            upload: (formData: FormData) => Promise<Record<string, unknown>>;
            update: (id: string, body: Record<string, unknown>) => Promise<Record<string, unknown>>;
            delete: (id: string) => Promise<void>;
            bin: () => Promise<Record<string, unknown>[]>;
            restore: (id: string) => Promise<Record<string, unknown>>;
            replace: (id: string, formData: FormData) => Promise<Record<string, unknown>>;
            deleteForever: (id: string) => Promise<void>;
            emptyBin: () => Promise<{
                deleted: number;
            }>;
            regenerate: (assetIds?: string[], options?: {
                background?: boolean;
            }) => Promise<{
                processed?: number;
                errors?: number;
                queued?: number;
            }>;
            move: (id: string, folder: string) => Promise<Record<string, unknown>>;
        };
        assetConfig: {
            get: () => Promise<Record<string, unknown>>;
            update: (body: Record<string, unknown>) => Promise<Record<string, unknown>>;
        };
        mediaSettings: {
            get: () => Promise<import("../project/mediaSettings.js").MediaSettings>;
            update: (body: import("../project/mediaSettings.js").MediaSettingsUpdate) => Promise<Pick<import("../project/mediaSettings.js").MediaSettings, "assetConfig" | "videoProviders">>;
            checkStorage: (body: import("../project/mediaSettings.js").StorageSettings) => Promise<{
                ok: boolean;
                error?: string;
            }>;
            moveStorage: (body: import("../project/mediaSettings.js").StorageSettings) => Promise<{
                moved: number;
            }>;
        };
        blocks: {
            list: () => Promise<Record<string, unknown>>;
            get: (id: string) => Promise<Record<string, unknown>>;
            create: (body: Record<string, unknown>) => Promise<Record<string, unknown>>;
            update: (id: string, body: Record<string, unknown>) => Promise<Record<string, unknown>>;
            delete: (id: string) => Promise<void>;
        };
        apiKeys: {
            list: () => Promise<import("../project/apiKeys.js").ProjectApiKeyMeta[]>;
            create: (body?: import("../project/apiKeys.js").ProjectApiKeyCreateBody) => Promise<import("../project/apiKeys.js").ProjectApiKeyCreateResponse>;
            rotate: (keyId: string) => Promise<import("../project/apiKeys.js").ProjectApiKeyCreateResponse>;
            revoke: (keyId: string) => Promise<void>;
            patch: (keyId: string, body: import("../project/apiKeys.js").ProjectApiKeyPatchBody) => Promise<import("../project/apiKeys.js").ProjectApiKeyMeta>;
        };
    };
    baseURL: string;
    setAuth(auth: import("../types.js").MoteurAuth | undefined): void;
    request<T = unknown>(options: import("axios").AxiosRequestConfig): Promise<T>;
    get<T = unknown>(url: string, params?: Record<string, string | number | boolean | undefined>): Promise<T>;
    post<T = unknown>(url: string, data?: unknown): Promise<T>;
    put<T = unknown>(url: string, data?: unknown): Promise<T>;
    patch<T = unknown>(url: string, data?: unknown): Promise<T>;
    delete<T = unknown>(url: string): Promise<T>;
    _raw: import("axios").AxiosInstance;
};
export type MoteurAdminClient = ReturnType<typeof createMoteurAdminClient>;
//# sourceMappingURL=adminClient.d.ts.map