import type { PageMove } from '../project/pages.js';
import type { SubmissionListParams } from '../project/submissions.js';
import type { MoteurClient } from '../client.js';
import { type MediaSettingsUpdate, type StorageSettings } from '../project/mediaSettings.js';
import { type ProjectApiKeyCreateBody, type ProjectApiKeyPatchBody } from '../project/apiKeys.js';
import type { CreateScheduleInput, ListSchedulesOptions } from '@moteurio/types';
/** Project-scoped API: same HTTP routes as the root client, with `projectId` fixed. */
export declare function createProjectClient(client: MoteurClient, 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: 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?: 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?: ListSchedulesOptions) => Promise<{
            schedules: import("@moteurio/types").Schedule[];
        }>;
        get: (scheduleId: string) => Promise<import("@moteurio/types").Schedule>;
        create: (body: 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: MediaSettingsUpdate) => Promise<Pick<import("../project/mediaSettings.js").MediaSettings, "assetConfig" | "videoProviders">>;
        checkStorage: (body: StorageSettings) => Promise<{
            ok: boolean;
            error?: string;
        }>;
        moveStorage: (body: 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?: 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: ProjectApiKeyPatchBody) => Promise<import("../project/apiKeys.js").ProjectApiKeyMeta>;
    };
};
export type ProjectClient = ReturnType<typeof createProjectClient>;
//# sourceMappingURL=forProject.d.ts.map