@plone/client/dist/index.d.ts

JavaScript Plone REST API client - JS framework agnostic library based on TanStack Query

import * as _tanstack_react_query from '@tanstack/react-query';
import { z } from 'zod';
import * as _plone_types from '@plone/types';

declare const PloneClientConfigSchema: z.ZodObject<{
    apiPath: z.ZodString;
    token: z.ZodOptional<z.ZodString>;
}, "strip", z.ZodTypeAny, {
    apiPath: string;
    token?: string | undefined;
}, {
    apiPath: string;
    token?: string | undefined;
}>;
type PloneClientConfig = z.infer<typeof PloneClientConfigSchema>;

declare const unlinkTranslationArgsSchema: z.ZodObject<{
    path: z.ZodString;
    data: z.ZodObject<{
        language: z.ZodString;
    }, "strip", z.ZodTypeAny, {
        language: string;
    }, {
        language: string;
    }>;
    config: z.ZodObject<{
        apiPath: z.ZodString;
        token: z.ZodOptional<z.ZodString>;
    }, "strip", z.ZodTypeAny, {
        apiPath: string;
        token?: string | undefined;
    }, {
        apiPath: string;
        token?: string | undefined;
    }>;
}, "strip", z.ZodTypeAny, {
    path: string;
    data: {
        language: string;
    };
    config: {
        apiPath: string;
        token?: string | undefined;
    };
}, {
    path: string;
    data: {
        language: string;
    };
    config: {
        apiPath: string;
        token?: string | undefined;
    };
}>;
type UnlinkTranslationArgs = z.infer<typeof unlinkTranslationArgsSchema>;

declare const linkTranslationArgsSchema: z.ZodObject<{
    path: z.ZodString;
    data: z.ZodObject<{
        id: z.ZodString;
    }, "strip", z.ZodTypeAny, {
        id: string;
    }, {
        id: string;
    }>;
    config: z.ZodObject<{
        apiPath: z.ZodString;
        token: z.ZodOptional<z.ZodString>;
    }, "strip", z.ZodTypeAny, {
        apiPath: string;
        token?: string | undefined;
    }, {
        apiPath: string;
        token?: string | undefined;
    }>;
}, "strip", z.ZodTypeAny, {
    path: string;
    data: {
        id: string;
    };
    config: {
        apiPath: string;
        token?: string | undefined;
    };
}, {
    path: string;
    data: {
        id: string;
    };
    config: {
        apiPath: string;
        token?: string | undefined;
    };
}>;
type LinkTranslationArgs = z.infer<typeof linkTranslationArgsSchema>;

declare const getTranslationSchema: z.ZodObject<{
    path: z.ZodString;
}, "strip", z.ZodTypeAny, {
    path: string;
}, {
    path: string;
}>;
type TranslationArgs = z.infer<typeof getTranslationSchema> & {
    config: PloneClientConfig;
};

declare const emailSendArgsSchema: z.ZodObject<{
    data: z.ZodObject<{
        name: z.ZodString;
        from: z.ZodString;
        to: z.ZodString;
        subject: z.ZodString;
        message: z.ZodString;
    }, "strip", z.ZodTypeAny, {
        message: string;
        name: string;
        from: string;
        subject: string;
        to: string;
    }, {
        message: string;
        name: string;
        from: string;
        subject: string;
        to: string;
    }>;
    config: z.ZodObject<{
        apiPath: z.ZodString;
        token: z.ZodOptional<z.ZodString>;
    }, "strip", z.ZodTypeAny, {
        apiPath: string;
        token?: string | undefined;
    }, {
        apiPath: string;
        token?: string | undefined;
    }>;
}, "strip", z.ZodTypeAny, {
    data: {
        message: string;
        name: string;
        from: string;
        subject: string;
        to: string;
    };
    config: {
        apiPath: string;
        token?: string | undefined;
    };
}, {
    data: {
        message: string;
        name: string;
        from: string;
        subject: string;
        to: string;
    };
    config: {
        apiPath: string;
        token?: string | undefined;
    };
}>;
type EmailSendArgs = z.infer<typeof emailSendArgsSchema>;

declare const emailNotificationArgsSchema: z.ZodObject<{
    user: z.ZodOptional<z.ZodString>;
    data: z.ZodObject<{
        name: z.ZodString;
        from: z.ZodString;
        subject: z.ZodString;
        message: z.ZodString;
    }, "strip", z.ZodTypeAny, {
        message: string;
        name: string;
        from: string;
        subject: string;
    }, {
        message: string;
        name: string;
        from: string;
        subject: string;
    }>;
    config: z.ZodObject<{
        apiPath: z.ZodString;
        token: z.ZodOptional<z.ZodString>;
    }, "strip", z.ZodTypeAny, {
        apiPath: string;
        token?: string | undefined;
    }, {
        apiPath: string;
        token?: string | undefined;
    }>;
}, "strip", z.ZodTypeAny, {
    data: {
        message: string;
        name: string;
        from: string;
        subject: string;
    };
    config: {
        apiPath: string;
        token?: string | undefined;
    };
    user?: string | undefined;
}, {
    data: {
        message: string;
        name: string;
        from: string;
        subject: string;
    };
    config: {
        apiPath: string;
        token?: string | undefined;
    };
    user?: string | undefined;
}>;
type EmailNotificationArgs = z.infer<typeof emailNotificationArgsSchema>;

declare const deleteCommentArgsSchema: z.ZodObject<{
    path: z.ZodString;
    comment_id: z.ZodString;
    config: z.ZodObject<{
        apiPath: z.ZodString;
        token: z.ZodOptional<z.ZodString>;
    }, "strip", z.ZodTypeAny, {
        apiPath: string;
        token?: string | undefined;
    }, {
        apiPath: string;
        token?: string | undefined;
    }>;
}, "strip", z.ZodTypeAny, {
    path: string;
    config: {
        apiPath: string;
        token?: string | undefined;
    };
    comment_id: string;
}, {
    path: string;
    config: {
        apiPath: string;
        token?: string | undefined;
    };
    comment_id: string;
}>;
type DeleteCommentArgs = z.infer<typeof deleteCommentArgsSchema>;

declare const updateCommentArgsSchema: z.ZodObject<{
    path: z.ZodString;
    comment_id: z.ZodString;
    data: z.ZodObject<{
        text: z.ZodString;
    }, "strip", z.ZodTypeAny, {
        text: string;
    }, {
        text: string;
    }>;
    config: z.ZodObject<{
        apiPath: z.ZodString;
        token: z.ZodOptional<z.ZodString>;
    }, "strip", z.ZodTypeAny, {
        apiPath: string;
        token?: string | undefined;
    }, {
        apiPath: string;
        token?: string | undefined;
    }>;
}, "strip", z.ZodTypeAny, {
    path: string;
    data: {
        text: string;
    };
    config: {
        apiPath: string;
        token?: string | undefined;
    };
    comment_id: string;
}, {
    path: string;
    data: {
        text: string;
    };
    config: {
        apiPath: string;
        token?: string | undefined;
    };
    comment_id: string;
}>;
type UpdateCommentArgs = z.infer<typeof updateCommentArgsSchema>;

declare const createCommentArgsSchema: z.ZodObject<{
    path: z.ZodString;
    reply_id: z.ZodOptional<z.ZodString>;
    data: z.ZodObject<{
        text: z.ZodString;
    }, "strip", z.ZodTypeAny, {
        text: string;
    }, {
        text: string;
    }>;
    config: z.ZodObject<{
        apiPath: z.ZodString;
        token: z.ZodOptional<z.ZodString>;
    }, "strip", z.ZodTypeAny, {
        apiPath: string;
        token?: string | undefined;
    }, {
        apiPath: string;
        token?: string | undefined;
    }>;
}, "strip", z.ZodTypeAny, {
    path: string;
    data: {
        text: string;
    };
    config: {
        apiPath: string;
        token?: string | undefined;
    };
    reply_id?: string | undefined;
}, {
    path: string;
    data: {
        text: string;
    };
    config: {
        apiPath: string;
        token?: string | undefined;
    };
    reply_id?: string | undefined;
}>;
type CreateCommentArgs = z.infer<typeof createCommentArgsSchema>;

declare const getCommentsSchema: z.ZodObject<{
    path: z.ZodString;
}, "strip", z.ZodTypeAny, {
    path: string;
}, {
    path: string;
}>;
type CommentsArgs = z.infer<typeof getCommentsSchema> & {
    config: PloneClientConfig;
};

declare const updateTypeFieldArgsSchema: z.ZodObject<{
    contentPath: z.ZodString;
    data: z.ZodObject<{
        description: z.ZodOptional<z.ZodString>;
        maxLength: z.ZodOptional<z.ZodNumber>;
        minLength: z.ZodOptional<z.ZodNumber>;
        fields: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
        required: z.ZodOptional<z.ZodBoolean>;
        title: z.ZodOptional<z.ZodString>;
        properties: z.ZodOptional<z.ZodAny>;
        fieldsets: z.ZodOptional<z.ZodArray<z.ZodAny, "many">>;
    }, "strip", z.ZodTypeAny, {
        description?: string | undefined;
        maxLength?: number | undefined;
        minLength?: number | undefined;
        fields?: string[] | undefined;
        required?: boolean | undefined;
        title?: string | undefined;
        properties?: any;
        fieldsets?: any[] | undefined;
    }, {
        description?: string | undefined;
        maxLength?: number | undefined;
        minLength?: number | undefined;
        fields?: string[] | undefined;
        required?: boolean | undefined;
        title?: string | undefined;
        properties?: any;
        fieldsets?: any[] | undefined;
    }>;
    config: z.ZodObject<{
        apiPath: z.ZodString;
        token: z.ZodOptional<z.ZodString>;
    }, "strip", z.ZodTypeAny, {
        apiPath: string;
        token?: string | undefined;
    }, {
        apiPath: string;
        token?: string | undefined;
    }>;
}, "strip", z.ZodTypeAny, {
    data: {
        description?: string | undefined;
        maxLength?: number | undefined;
        minLength?: number | undefined;
        fields?: string[] | undefined;
        required?: boolean | undefined;
        title?: string | undefined;
        properties?: any;
        fieldsets?: any[] | undefined;
    };
    config: {
        apiPath: string;
        token?: string | undefined;
    };
    contentPath: string;
}, {
    data: {
        description?: string | undefined;
        maxLength?: number | undefined;
        minLength?: number | undefined;
        fields?: string[] | undefined;
        required?: boolean | undefined;
        title?: string | undefined;
        properties?: any;
        fieldsets?: any[] | undefined;
    };
    config: {
        apiPath: string;
        token?: string | undefined;
    };
    contentPath: string;
}>;
type UpdateTypeFieldArgs = z.infer<typeof updateTypeFieldArgsSchema>;

declare const createTypeFieldArgsSchema: z.ZodObject<{
    contentPath: z.ZodString;
    data: z.ZodObject<{
        description: z.ZodString;
        factory: z.ZodString;
        required: z.ZodOptional<z.ZodBoolean>;
        title: z.ZodString;
    }, "strip", z.ZodTypeAny, {
        description: string;
        title: string;
        factory: string;
        required?: boolean | undefined;
    }, {
        description: string;
        title: string;
        factory: string;
        required?: boolean | undefined;
    }>;
    config: z.ZodObject<{
        apiPath: z.ZodString;
        token: z.ZodOptional<z.ZodString>;
    }, "strip", z.ZodTypeAny, {
        apiPath: string;
        token?: string | undefined;
    }, {
        apiPath: string;
        token?: string | undefined;
    }>;
}, "strip", z.ZodTypeAny, {
    data: {
        description: string;
        title: string;
        factory: string;
        required?: boolean | undefined;
    };
    config: {
        apiPath: string;
        token?: string | undefined;
    };
    contentPath: string;
}, {
    data: {
        description: string;
        title: string;
        factory: string;
        required?: boolean | undefined;
    };
    config: {
        apiPath: string;
        token?: string | undefined;
    };
    contentPath: string;
}>;
type CreateTypeFieldArgs = z.infer<typeof createTypeFieldArgsSchema>;

declare const getTypeFieldSchema: z.ZodObject<{
    contentFieldPath: z.ZodString;
}, "strip", z.ZodTypeAny, {
    contentFieldPath: string;
}, {
    contentFieldPath: string;
}>;
type GetTypeFieldArgs = z.infer<typeof getTypeFieldSchema> & {
    config: PloneClientConfig;
};

declare const getTypeSchema: z.ZodObject<{
    contentPath: z.ZodString;
}, "strip", z.ZodTypeAny, {
    contentPath: string;
}, {
    contentPath: string;
}>;
type GetTypeArgs = z.infer<typeof getTypeSchema> & {
    config: PloneClientConfig;
};

type GetTypesArgs = {
    config: PloneClientConfig;
};

declare const getNavrootSchema: z.ZodObject<{
    path: z.ZodString;
    language: z.ZodOptional<z.ZodString>;
}, "strip", z.ZodTypeAny, {
    path: string;
    language?: string | undefined;
}, {
    path: string;
    language?: string | undefined;
}>;
type NavrootArgs = z.infer<typeof getNavrootSchema> & {
    config: PloneClientConfig;
};

type QueryStringArgs = {
    config: PloneClientConfig;
};

declare const getVocabulariesSchema: z.ZodObject<{
    path: z.ZodString;
    title: z.ZodOptional<z.ZodString>;
    token: z.ZodOptional<z.ZodString>;
    tokens: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
}, "strip", z.ZodTypeAny, {
    path: string;
    title?: string | undefined;
    token?: string | undefined;
    tokens?: string[] | undefined;
}, {
    path: string;
    title?: string | undefined;
    token?: string | undefined;
    tokens?: string[] | undefined;
}>;
type VocabulariesArgs = z.infer<typeof getVocabulariesSchema> & {
    config: PloneClientConfig;
};

type VocabulariesListArgs = {
    config: PloneClientConfig;
};

declare const createWorkflowArgsSchema: z.ZodObject<{
    path: z.ZodString;
    data: z.ZodOptional<z.ZodObject<{
        comment: z.ZodOptional<z.ZodString>;
        effective: z.ZodOptional<z.ZodString>;
        expires: z.ZodOptional<z.ZodString>;
        include_children: z.ZodOptional<z.ZodBoolean>;
    }, "strip", z.ZodTypeAny, {
        comment?: string | undefined;
        effective?: string | undefined;
        expires?: string | undefined;
        include_children?: boolean | undefined;
    }, {
        comment?: string | undefined;
        effective?: string | undefined;
        expires?: string | undefined;
        include_children?: boolean | undefined;
    }>>;
    config: z.ZodObject<{
        apiPath: z.ZodString;
        token: z.ZodOptional<z.ZodString>;
    }, "strip", z.ZodTypeAny, {
        apiPath: string;
        token?: string | undefined;
    }, {
        apiPath: string;
        token?: string | undefined;
    }>;
}, "strip", z.ZodTypeAny, {
    path: string;
    config: {
        apiPath: string;
        token?: string | undefined;
    };
    data?: {
        comment?: string | undefined;
        effective?: string | undefined;
        expires?: string | undefined;
        include_children?: boolean | undefined;
    } | undefined;
}, {
    path: string;
    config: {
        apiPath: string;
        token?: string | undefined;
    };
    data?: {
        comment?: string | undefined;
        effective?: string | undefined;
        expires?: string | undefined;
        include_children?: boolean | undefined;
    } | undefined;
}>;
type CreateWorkflowArgs = z.infer<typeof createWorkflowArgsSchema>;

declare const getWorkflowSchema: z.ZodObject<{
    path: z.ZodString;
}, "strip", z.ZodTypeAny, {
    path: string;
}, {
    path: string;
}>;
type WorkflowArgs = z.infer<typeof getWorkflowSchema> & {
    config: PloneClientConfig;
};

declare const updateLockArgsSchema: z.ZodObject<{
    path: z.ZodString;
    locktoken: z.ZodString;
    config: z.ZodObject<{
        apiPath: z.ZodString;
        token: z.ZodOptional<z.ZodString>;
    }, "strip", z.ZodTypeAny, {
        apiPath: string;
        token?: string | undefined;
    }, {
        apiPath: string;
        token?: string | undefined;
    }>;
}, "strip", z.ZodTypeAny, {
    path: string;
    config: {
        apiPath: string;
        token?: string | undefined;
    };
    locktoken: string;
}, {
    path: string;
    config: {
        apiPath: string;
        token?: string | undefined;
    };
    locktoken: string;
}>;
type UpdateLockArgs = z.infer<typeof updateLockArgsSchema>;

declare const createLockArgsSchema: z.ZodObject<{
    path: z.ZodString;
    data: z.ZodObject<{
        stealable: z.ZodOptional<z.ZodBoolean>;
        timeout: z.ZodOptional<z.ZodNumber>;
    }, "strip", z.ZodTypeAny, {
        stealable?: boolean | undefined;
        timeout?: number | undefined;
    }, {
        stealable?: boolean | undefined;
        timeout?: number | undefined;
    }>;
    config: z.ZodObject<{
        apiPath: z.ZodString;
        token: z.ZodOptional<z.ZodString>;
    }, "strip", z.ZodTypeAny, {
        apiPath: string;
        token?: string | undefined;
    }, {
        apiPath: string;
        token?: string | undefined;
    }>;
}, "strip", z.ZodTypeAny, {
    path: string;
    data: {
        stealable?: boolean | undefined;
        timeout?: number | undefined;
    };
    config: {
        apiPath: string;
        token?: string | undefined;
    };
}, {
    path: string;
    data: {
        stealable?: boolean | undefined;
        timeout?: number | undefined;
    };
    config: {
        apiPath: string;
        token?: string | undefined;
    };
}>;
type CreateLockArgs = z.infer<typeof createLockArgsSchema>;

declare const getLockSchema: z.ZodObject<{
    path: z.ZodString;
}, "strip", z.ZodTypeAny, {
    path: string;
}, {
    path: string;
}>;
type LockArgs = z.infer<typeof getLockSchema> & {
    config: PloneClientConfig;
};

declare const runUpgradeArgsSchema: z.ZodObject<{
    data: z.ZodObject<{
        dry_run: z.ZodBoolean;
    }, "strip", z.ZodTypeAny, {
        dry_run: boolean;
    }, {
        dry_run: boolean;
    }>;
    config: z.ZodObject<{
        apiPath: z.ZodString;
        token: z.ZodOptional<z.ZodString>;
    }, "strip", z.ZodTypeAny, {
        apiPath: string;
        token?: string | undefined;
    }, {
        apiPath: string;
        token?: string | undefined;
    }>;
}, "strip", z.ZodTypeAny, {
    data: {
        dry_run: boolean;
    };
    config: {
        apiPath: string;
        token?: string | undefined;
    };
}, {
    data: {
        dry_run: boolean;
    };
    config: {
        apiPath: string;
        token?: string | undefined;
    };
}>;
type RunUpgradeArgs = z.infer<typeof runUpgradeArgsSchema>;

type GetUpgradeArgs = {
    config: PloneClientConfig;
};

declare const updateRegistryArgsSchema: z.ZodObject<{
    data: z.ZodRecord<z.ZodString, z.ZodAny>;
    config: z.ZodObject<{
        apiPath: z.ZodString;
        token: z.ZodOptional<z.ZodString>;
    }, "strip", z.ZodTypeAny, {
        apiPath: string;
        token?: string | undefined;
    }, {
        apiPath: string;
        token?: string | undefined;
    }>;
}, "strip", z.ZodTypeAny, {
    data: Record<string, any>;
    config: {
        apiPath: string;
        token?: string | undefined;
    };
}, {
    data: Record<string, any>;
    config: {
        apiPath: string;
        token?: string | undefined;
    };
}>;
type UpdateRegistryArgs = z.infer<typeof updateRegistryArgsSchema>;

declare const getRegistrySchema: z.ZodObject<{
    registryName: z.ZodString;
}, "strip", z.ZodTypeAny, {
    registryName: string;
}, {
    registryName: string;
}>;
type GetRegistryArgs = z.infer<typeof getRegistrySchema> & {
    config: PloneClientConfig;
};

type GetRegistriesArgs = {
    config: PloneClientConfig;
};

type SiteArgs = {
    config: PloneClientConfig;
};

declare const copyMoveDataSchema: z.ZodObject<{
    path: z.ZodString;
    data: z.ZodObject<{
        source: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>;
    }, "strip", z.ZodTypeAny, {
        source: (string | string[]) & (string | string[] | undefined);
    }, {
        source: (string | string[]) & (string | string[] | undefined);
    }>;
}, "strip", z.ZodTypeAny, {
    path: string;
    data: {
        source: (string | string[]) & (string | string[] | undefined);
    };
}, {
    path: string;
    data: {
        source: (string | string[]) & (string | string[] | undefined);
    };
}>;

type MoveArgs = z.infer<typeof copyMoveDataSchema> & {
    config: PloneClientConfig;
};

type CopyArgs = z.infer<typeof copyMoveDataSchema> & {
    config: PloneClientConfig;
};

declare const getSourceSchema: z.ZodObject<{
    path: z.ZodString;
    field: z.ZodString;
}, "strip", z.ZodTypeAny, {
    path: string;
    field: string;
}, {
    path: string;
    field: string;
}>;
type SourceArgs = z.infer<typeof getSourceSchema> & {
    config: PloneClientConfig;
};

declare const getQuerysourceSchema: z.ZodObject<{
    path: z.ZodString;
    field: z.ZodString;
    query: z.ZodString;
}, "strip", z.ZodTypeAny, {
    path: string;
    query: string;
    field: string;
}, {
    path: string;
    query: string;
    field: string;
}>;
type QuerysourceArgs = z.infer<typeof getQuerysourceSchema> & {
    config: PloneClientConfig;
};

declare const getSearchSchema: z.ZodObject<{
    query: z.ZodIntersection<z.ZodObject<{
        path: z.ZodOptional<z.ZodObject<{
            query: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>;
            depth: z.ZodOptional<z.ZodNumber>;
        }, "strip", z.ZodTypeAny, {
            query: (string | string[]) & (string | string[] | undefined);
            depth?: number | undefined;
        }, {
            query: (string | string[]) & (string | string[] | undefined);
            depth?: number | undefined;
        }>>;
        sort_on: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>>;
        SearchableText: z.ZodOptional<z.ZodString>;
        metadata_fields: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>>;
        fullobjects: z.ZodOptional<z.ZodNumber>;
    }, "strip", z.ZodTypeAny, {
        path?: {
            query: (string | string[]) & (string | string[] | undefined);
            depth?: number | undefined;
        } | undefined;
        sort_on?: string | string[] | undefined;
        SearchableText?: string | undefined;
        metadata_fields?: string | string[] | undefined;
        fullobjects?: number | undefined;
    }, {
        path?: {
            query: (string | string[]) & (string | string[] | undefined);
            depth?: number | undefined;
        } | undefined;
        sort_on?: string | string[] | undefined;
        SearchableText?: string | undefined;
        metadata_fields?: string | string[] | undefined;
        fullobjects?: number | undefined;
    }>, z.ZodRecord<z.ZodString, z.ZodAny>>;
}, "strip", z.ZodTypeAny, {
    query: {
        path?: {
            query: (string | string[]) & (string | string[] | undefined);
            depth?: number | undefined;
        } | undefined;
        sort_on?: string | string[] | undefined;
        SearchableText?: string | undefined;
        metadata_fields?: string | string[] | undefined;
        fullobjects?: number | undefined;
    } & Record<string, any>;
}, {
    query: {
        path?: {
            query: (string | string[]) & (string | string[] | undefined);
            depth?: number | undefined;
        } | undefined;
        sort_on?: string | string[] | undefined;
        SearchableText?: string | undefined;
        metadata_fields?: string | string[] | undefined;
        fullobjects?: number | undefined;
    } & Record<string, any>;
}>;

type SearchArgs = z.infer<typeof getSearchSchema> & {
    config: PloneClientConfig;
};

declare const deleteControlpanelArgsSchema: z.ZodObject<{
    path: z.ZodString;
    data: z.ZodAny;
    config: z.ZodObject<{
        apiPath: z.ZodString;
        token: z.ZodOptional<z.ZodString>;
    }, "strip", z.ZodTypeAny, {
        apiPath: string;
        token?: string | undefined;
    }, {
        apiPath: string;
        token?: string | undefined;
    }>;
}, "strip", z.ZodTypeAny, {
    path: string;
    config: {
        apiPath: string;
        token?: string | undefined;
    };
    data?: any;
}, {
    path: string;
    config: {
        apiPath: string;
        token?: string | undefined;
    };
    data?: any;
}>;
type DeleteControlpanelArgs = z.infer<typeof deleteControlpanelArgsSchema>;

declare const updateControlpanelArgsSchema: z.ZodObject<{
    path: z.ZodString;
    data: z.ZodAny;
    config: z.ZodObject<{
        apiPath: z.ZodString;
        token: z.ZodOptional<z.ZodString>;
    }, "strip", z.ZodTypeAny, {
        apiPath: string;
        token?: string | undefined;
    }, {
        apiPath: string;
        token?: string | undefined;
    }>;
}, "strip", z.ZodTypeAny, {
    path: string;
    config: {
        apiPath: string;
        token?: string | undefined;
    };
    data?: any;
}, {
    path: string;
    config: {
        apiPath: string;
        token?: string | undefined;
    };
    data?: any;
}>;
type UpdateControlpanelArgs = z.infer<typeof updateControlpanelArgsSchema>;

declare const createControlpanelArgsSchema: z.ZodObject<{
    path: z.ZodString;
    data: z.ZodAny;
    config: z.ZodObject<{
        apiPath: z.ZodString;
        token: z.ZodOptional<z.ZodString>;
    }, "strip", z.ZodTypeAny, {
        apiPath: string;
        token?: string | undefined;
    }, {
        apiPath: string;
        token?: string | undefined;
    }>;
}, "strip", z.ZodTypeAny, {
    path: string;
    config: {
        apiPath: string;
        token?: string | undefined;
    };
    data?: any;
}, {
    path: string;
    config: {
        apiPath: string;
        token?: string | undefined;
    };
    data?: any;
}>;
type CreateControlpanelArgs = z.infer<typeof createControlpanelArgsSchema>;

declare const getControlpanelSchema: z.ZodObject<{
    path: z.ZodString;
}, "strip", z.ZodTypeAny, {
    path: string;
}, {
    path: string;
}>;
type ControlpanelArgs = z.infer<typeof getControlpanelSchema> & {
    config: PloneClientConfig;
};

type ControlpanelsArgs = {
    config: PloneClientConfig;
};

declare const updateRulesArgsSchema: z.ZodObject<{
    data: z.ZodObject<{
        'form.button.Bubble': z.ZodOptional<z.ZodBoolean>;
        'form.button.NoBubble': z.ZodOptional<z.ZodBoolean>;
        'form.button.Enable': z.ZodOptional<z.ZodBoolean>;
        'form.button.Disable': z.ZodOptional<z.ZodBoolean>;
        rules_ids: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
        operation: z.ZodOptional<z.ZodString>;
        rule_id: z.ZodOptional<z.ZodString>;
    }, "strip", z.ZodTypeAny, {
        'form.button.Bubble'?: boolean | undefined;
        'form.button.NoBubble'?: boolean | undefined;
        'form.button.Enable'?: boolean | undefined;
        'form.button.Disable'?: boolean | undefined;
        rules_ids?: string[] | undefined;
        operation?: string | undefined;
        rule_id?: string | undefined;
    }, {
        'form.button.Bubble'?: boolean | undefined;
        'form.button.NoBubble'?: boolean | undefined;
        'form.button.Enable'?: boolean | undefined;
        'form.button.Disable'?: boolean | undefined;
        rules_ids?: string[] | undefined;
        operation?: string | undefined;
        rule_id?: string | undefined;
    }>;
    config: z.ZodObject<{
        apiPath: z.ZodString;
        token: z.ZodOptional<z.ZodString>;
    }, "strip", z.ZodTypeAny, {
        apiPath: string;
        token?: string | undefined;
    }, {
        apiPath: string;
        token?: string | undefined;
    }>;
}, "strip", z.ZodTypeAny, {
    data: {
        'form.button.Bubble'?: boolean | undefined;
        'form.button.NoBubble'?: boolean | undefined;
        'form.button.Enable'?: boolean | undefined;
        'form.button.Disable'?: boolean | undefined;
        rules_ids?: string[] | undefined;
        operation?: string | undefined;
        rule_id?: string | undefined;
    };
    config: {
        apiPath: string;
        token?: string | undefined;
    };
}, {
    data: {
        'form.button.Bubble'?: boolean | undefined;
        'form.button.NoBubble'?: boolean | undefined;
        'form.button.Enable'?: boolean | undefined;
        'form.button.Disable'?: boolean | undefined;
        rules_ids?: string[] | undefined;
        operation?: string | undefined;
        rule_id?: string | undefined;
    };
    config: {
        apiPath: string;
        token?: string | undefined;
    };
}>;
type UpdateRulesArgs = z.infer<typeof updateRulesArgsSchema>;

declare const createRuleArgsSchema: z.ZodObject<{
    ruleId: z.ZodString;
    config: z.ZodObject<{
        apiPath: z.ZodString;
        token: z.ZodOptional<z.ZodString>;
    }, "strip", z.ZodTypeAny, {
        apiPath: string;
        token?: string | undefined;
    }, {
        apiPath: string;
        token?: string | undefined;
    }>;
}, "strip", z.ZodTypeAny, {
    config: {
        apiPath: string;
        token?: string | undefined;
    };
    ruleId: string;
}, {
    config: {
        apiPath: string;
        token?: string | undefined;
    };
    ruleId: string;
}>;
type CreateRuleArgs = z.infer<typeof createRuleArgsSchema>;

type GetRulesArgs = {
    config: PloneClientConfig;
};

declare const postQuerystringSearchArgsSchema: z.ZodObject<{
    data: z.ZodObject<{
        b_start: z.ZodOptional<z.ZodString>;
        b_size: z.ZodOptional<z.ZodString>;
        limit: z.ZodOptional<z.ZodString>;
        sort_on: z.ZodOptional<z.ZodString>;
        sort_order: z.ZodOptional<z.ZodString>;
        fullobjects: z.ZodOptional<z.ZodBoolean>;
        query: z.ZodArray<z.ZodObject<{
            i: z.ZodString;
            o: z.ZodString;
            v: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>;
        }, "strip", z.ZodTypeAny, {
            i: string;
            o: string;
            v: (string | string[]) & (string | string[] | undefined);
        }, {
            i: string;
            o: string;
            v: (string | string[]) & (string | string[] | undefined);
        }>, "many">;
    }, "strip", z.ZodTypeAny, {
        query: {
            i: string;
            o: string;
            v: (string | string[]) & (string | string[] | undefined);
        }[];
        b_start?: string | undefined;
        b_size?: string | undefined;
        limit?: string | undefined;
        sort_on?: string | undefined;
        sort_order?: string | undefined;
        fullobjects?: boolean | undefined;
    }, {
        query: {
            i: string;
            o: string;
            v: (string | string[]) & (string | string[] | undefined);
        }[];
        b_start?: string | undefined;
        b_size?: string | undefined;
        limit?: string | undefined;
        sort_on?: string | undefined;
        sort_order?: string | undefined;
        fullobjects?: boolean | undefined;
    }>;
    config: z.ZodObject<{
        apiPath: z.ZodString;
        token: z.ZodOptional<z.ZodString>;
    }, "strip", z.ZodTypeAny, {
        apiPath: string;
        token?: string | undefined;
    }, {
        apiPath: string;
        token?: string | undefined;
    }>;
}, "strip", z.ZodTypeAny, {
    data: {
        query: {
            i: string;
            o: string;
            v: (string | string[]) & (string | string[] | undefined);
        }[];
        b_start?: string | undefined;
        b_size?: string | undefined;
        limit?: string | undefined;
        sort_on?: string | undefined;
        sort_order?: string | undefined;
        fullobjects?: boolean | undefined;
    };
    config: {
        apiPath: string;
        token?: string | undefined;
    };
}, {
    data: {
        query: {
            i: string;
            o: string;
            v: (string | string[]) & (string | string[] | undefined);
        }[];
        b_start?: string | undefined;
        b_size?: string | undefined;
        limit?: string | undefined;
        sort_on?: string | undefined;
        sort_order?: string | undefined;
        fullobjects?: boolean | undefined;
    };
    config: {
        apiPath: string;
        token?: string | undefined;
    };
}>;
type PostQuerystringSearchArgs = z.infer<typeof postQuerystringSearchArgsSchema>;

declare const querystringSearchDataSchema: z.ZodObject<{
    b_start: z.ZodOptional<z.ZodString>;
    b_size: z.ZodOptional<z.ZodString>;
    limit: z.ZodOptional<z.ZodString>;
    sort_on: z.ZodOptional<z.ZodString>;
    sort_order: z.ZodOptional<z.ZodString>;
    fullobjects: z.ZodOptional<z.ZodBoolean>;
    query: z.ZodArray<z.ZodObject<{
        i: z.ZodString;
        o: z.ZodString;
        v: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>;
    }, "strip", z.ZodTypeAny, {
        i: string;
        o: string;
        v: (string | string[]) & (string | string[] | undefined);
    }, {
        i: string;
        o: string;
        v: (string | string[]) & (string | string[] | undefined);
    }>, "many">;
}, "strip", z.ZodTypeAny, {
    query: {
        i: string;
        o: string;
        v: (string | string[]) & (string | string[] | undefined);
    }[];
    b_start?: string | undefined;
    b_size?: string | undefined;
    limit?: string | undefined;
    sort_on?: string | undefined;
    sort_order?: string | undefined;
    fullobjects?: boolean | undefined;
}, {
    query: {
        i: string;
        o: string;
        v: (string | string[]) & (string | string[] | undefined);
    }[];
    b_start?: string | undefined;
    b_size?: string | undefined;
    limit?: string | undefined;
    sort_on?: string | undefined;
    sort_order?: string | undefined;
    fullobjects?: boolean | undefined;
}>;

type QuerystringSearchArgs = z.infer<typeof querystringSearchDataSchema> & {
    config: PloneClientConfig;
};

declare const checkInWorkingcopyArgsSchema: z.ZodObject<{
    path: z.ZodString;
    config: z.ZodObject<{
        apiPath: z.ZodString;
        token: z.ZodOptional<z.ZodString>;
    }, "strip", z.ZodTypeAny, {
        apiPath: string;
        token?: string | undefined;
    }, {
        apiPath: string;
        token?: string | undefined;
    }>;
}, "strip", z.ZodTypeAny, {
    path: string;
    config: {
        apiPath: string;
        token?: string | undefined;
    };
}, {
    path: string;
    config: {
        apiPath: string;
        token?: string | undefined;
    };
}>;
type CheckInWorkingcopyArgs = z.infer<typeof checkInWorkingcopyArgsSchema>;

declare const createWorkingcopyArgsSchema: z.ZodObject<{
    path: z.ZodString;
    config: z.ZodObject<{
        apiPath: z.ZodString;
        token: z.ZodOptional<z.ZodString>;
    }, "strip", z.ZodTypeAny, {
        apiPath: string;
        token?: string | undefined;
    }, {
        apiPath: string;
        token?: string | undefined;
    }>;
}, "strip", z.ZodTypeAny, {
    path: string;
    config: {
        apiPath: string;
        token?: string | undefined;
    };
}, {
    path: string;
    config: {
        apiPath: string;
        token?: string | undefined;
    };
}>;
type CreateWorkingcopyArgs = z.infer<typeof createWorkingcopyArgsSchema>;

declare const getWorkingcopySchema: z.ZodObject<{
    path: z.ZodString;
}, "strip", z.ZodTypeAny, {
    path: string;
}, {
    path: string;
}>;
type GetWorkingcopyArgs = z.infer<typeof getWorkingcopySchema> & {
    config: PloneClientConfig;
};

declare const getPrincipalsSchema: z.ZodObject<{
    search: z.ZodString;
}, "strip", z.ZodTypeAny, {
    search: string;
}, {
    search: string;
}>;
type PrincipalsArgs = z.infer<typeof getPrincipalsSchema> & {
    config: PloneClientConfig;
};

declare const revertTransactionsArgsSchema: z.ZodObject<{
    data: z.ZodObject<{
        transaction_ids: z.ZodArray<z.ZodString, "many">;
    }, "strip", z.ZodTypeAny, {
        transaction_ids: string[];
    }, {
        transaction_ids: string[];
    }>;
    config: z.ZodObject<{
        apiPath: z.ZodString;
        token: z.ZodOptional<z.ZodString>;
    }, "strip", z.ZodTypeAny, {
        apiPath: string;
        token?: string | undefined;
    }, {
        apiPath: string;
        token?: string | undefined;
    }>;
}, "strip", z.ZodTypeAny, {
    data: {
        transaction_ids: string[];
    };
    config: {
        apiPath: string;
        token?: string | undefined;
    };
}, {
    data: {
        transaction_ids: string[];
    };
    config: {
        apiPath: string;
        token?: string | undefined;
    };
}>;
type RevertTransactionsArgs = z.infer<typeof revertTransactionsArgsSchema>;

type GetTransactionsArgs = {
    config: PloneClientConfig;
};

type GetSystemArgs = {
    config: PloneClientConfig;
};

type GetRolesArgs = {
    config: PloneClientConfig;
};

type GetUserschemaArgs = {
    config: PloneClientConfig;
};

declare const fixRelationsArgsSchema: z.ZodObject<{
    data: z.ZodOptional<z.ZodObject<{
        flush: z.ZodOptional<z.ZodNumber>;
    }, "strip", z.ZodTypeAny, {
        flush?: number | undefined;
    }, {
        flush?: number | undefined;
    }>>;
    config: z.ZodObject<{
        apiPath: z.ZodString;
        token: z.ZodOptional<z.ZodString>;
    }, "strip", z.ZodTypeAny, {
        apiPath: string;
        token?: string | undefined;
    }, {
        apiPath: string;
        token?: string | undefined;
    }>;
}, "strip", z.ZodTypeAny, {
    config: {
        apiPath: string;
        token?: string | undefined;
    };
    data?: {
        flush?: number | undefined;
    } | undefined;
}, {
    config: {
        apiPath: string;
        token?: string | undefined;
    };
    data?: {
        flush?: number | undefined;
    } | undefined;
}>;
type FixRelationsArgs = z.infer<typeof fixRelationsArgsSchema>;

declare const deleteRelationsArgsSchema: z.ZodObject<{
    data: z.ZodObject<{
        items: z.ZodOptional<z.ZodArray<z.ZodObject<{
            relation: z.ZodString;
            source: z.ZodString;
            target: z.ZodString;
        }, "strip", z.ZodTypeAny, {
            source: string;
            relation: string;
            target: string;
        }, {
            source: string;
            relation: string;
            target: string;
        }>, "many">>;
        relation: z.ZodOptional<z.ZodString>;
        source: z.ZodOptional<z.ZodString>;
        target: z.ZodOptional<z.ZodString>;
    }, "strip", z.ZodTypeAny, {
        items?: {
            source: string;
            relation: string;
            target: string;
        }[] | undefined;
        relation?: string | undefined;
        source?: string | undefined;
        target?: string | undefined;
    }, {
        items?: {
            source: string;
            relation: string;
            target: string;
        }[] | undefined;
        relation?: string | undefined;
        source?: string | undefined;
        target?: string | undefined;
    }>;
    config: z.ZodObject<{
        apiPath: z.ZodString;
        token: z.ZodOptional<z.ZodString>;
    }, "strip", z.ZodTypeAny, {
        apiPath: string;
        token?: string | undefined;
    }, {
        apiPath: string;
        token?: string | undefined;
    }>;
}, "strip", z.ZodTypeAny, {
    data: {
        items?: {
            source: string;
            relation: string;
            target: string;
        }[] | undefined;
        relation?: string | undefined;
        source?: string | undefined;
        target?: string | undefined;
    };
    config: {
        apiPath: string;
        token?: string | undefined;
    };
}, {
    data: {
        items?: {
            source: string;
            relation: string;
            target: string;
        }[] | undefined;
        relation?: string | undefined;
        source?: string | undefined;
        target?: string | undefined;
    };
    config: {
        apiPath: string;
        token?: string | undefined;
    };
}>;
type DeleteRelationsArgs = z.infer<typeof deleteRelationsArgsSchema>;

declare const createRelationsArgsSchema: z.ZodObject<{
    data: z.ZodObject<{
        items: z.ZodArray<z.ZodObject<{
            relation: z.ZodString;
            source: z.ZodString;
            target: z.ZodString;
        }, "strip", z.ZodTypeAny, {
            source: string;
            relation: string;
            target: string;
        }, {
            source: string;
            relation: string;
            target: string;
        }>, "many">;
    }, "strip", z.ZodTypeAny, {
        items: {
            source: string;
            relation: string;
            target: string;
        }[];
    }, {
        items: {
            source: string;
            relation: string;
            target: string;
        }[];
    }>;
    config: z.ZodObject<{
        apiPath: z.ZodString;
        token: z.ZodOptional<z.ZodString>;
    }, "strip", z.ZodTypeAny, {
        apiPath: string;
        token?: string | undefined;
    }, {
        apiPath: string;
        token?: string | undefined;
    }>;
}, "strip", z.ZodTypeAny, {
    data: {
        items: {
            source: string;
            relation: string;
            target: string;
        }[];
    };
    config: {
        apiPath: string;
        token?: string | undefined;
    };
}, {
    data: {
        items: {
            source: string;
            relation: string;
            target: string;
        }[];
    };
    config: {
        apiPath: string;
        token?: string | undefined;
    };
}>;
type CreateRelationsArgs = z.infer<typeof createRelationsArgsSchema>;

declare const getRelationsSchema: z.ZodEffects<z.ZodObject<{
    source: z.ZodOptional<z.ZodString>;
    relation: z.ZodOptional<z.ZodString>;
    onlyBroken: z.ZodOptional<z.ZodBoolean>;
}, "strip", z.ZodTypeAny, {
    source?: string | undefined;
    relation?: string | undefined;
    onlyBroken?: boolean | undefined;
}, {
    source?: string | undefined;
    relation?: string | undefined;
    onlyBroken?: boolean | undefined;
}>, {
    source?: string | undefined;
    relation?: string | undefined;
    onlyBroken?: boolean | undefined;
}, {
    source?: string | undefined;
    relation?: string | undefined;
    onlyBroken?: boolean | undefined;
}>;
type RelationsArgs = z.infer<typeof getRelationsSchema> & {
    config: PloneClientConfig;
};

type GetRelationsListArgs = {
    config: PloneClientConfig;
};

declare const updateUserArgsSchema: z.ZodObject<{
    userId: z.ZodString;
    data: z.ZodObject<{
        description: z.ZodOptional<z.ZodString>;
        email: z.ZodOptional<z.ZodString>;
        fullname: z.ZodOptional<z.ZodString>;
        home_page: z.ZodOptional<z.ZodString>;
        location: z.ZodOptional<z.ZodString>;
        username: z.ZodOptional<z.ZodString>;
        portrait: z.ZodOptional<z.ZodObject<{
            'content-type': z.ZodString;
            data: z.ZodString;
            encoding: z.ZodString;
            filename: z.ZodString;
            scale: z.ZodOptional<z.ZodBoolean>;
        }, "strip", z.ZodTypeAny, {
            data: string;
            'content-type': string;
            encoding: string;
            filename: string;
            scale?: boolean | undefined;
        }, {
            data: string;
            'content-type': string;
            encoding: string;
            filename: string;
            scale?: boolean | undefined;
        }>>;
    }, "strip", z.ZodTypeAny, {
        description?: string | undefined;
        email?: string | undefined;
        fullname?: string | undefined;
        home_page?: string | undefined;
        location?: string | undefined;
        username?: string | undefined;
        portrait?: {
            data: string;
            'content-type': string;
            encoding: string;
            filename: string;
            scale?: boolean | undefined;
        } | undefined;
    }, {
        description?: string | undefined;
        email?: string | undefined;
        fullname?: string | undefined;
        home_page?: string | undefined;
        location?: string | undefined;
        username?: string | undefined;
        portrait?: {
            data: string;
            'content-type': string;
            encoding: string;
            filename: string;
            scale?: boolean | undefined;
        } | undefined;
    }>;
    config: z.ZodObject<{
        apiPath: z.ZodString;
        token: z.ZodOptional<z.ZodString>;
    }, "strip", z.ZodTypeAny, {
        apiPath: string;
        token?: string | undefined;
    }, {
        apiPath: string;
        token?: string | undefined;
    }>;
}, "strip", z.ZodTypeAny, {
    data: {
        description?: string | undefined;
        email?: string | undefined;
        fullname?: string | undefined;
        home_page?: string | undefined;
        location?: string | undefined;
        username?: string | undefined;
        portrait?: {
            data: string;
            'content-type': string;
            encoding: string;
            filename: string;
            scale?: boolean | undefined;
        } | undefined;
    };
    config: {
        apiPath: string;
        token?: string | undefined;
    };
    userId: string;
}, {
    data: {
        description?: string | undefined;
        email?: string | undefined;
        fullname?: string | undefined;
        home_page?: string | undefined;
        location?: string | undefined;
        username?: string | undefined;
        portrait?: {
            data: string;
            'content-type': string;
            encoding: string;
            filename: string;
            scale?: boolean | undefined;
        } | undefined;
    };
    config: {
        apiPath: string;
        token?: string | undefined;
    };
    userId: string;
}>;
type UpdateUserArgs = z.infer<typeof updateUserArgsSchema>;

declare const updatePasswordArgsSchema: z.ZodObject<{
    userId: z.ZodString;
    data: z.ZodObject<{
        new_password: z.ZodString;
        old_password: z.ZodString;
    }, "strip", z.ZodTypeAny, {
        new_password: string;
        old_password: string;
    }, {
        new_password: string;
        old_password: string;
    }>;
    config: z.ZodObject<{
        apiPath: z.ZodString;
        token: z.ZodOptional<z.ZodString>;
    }, "strip", z.ZodTypeAny, {
        apiPath: string;
        token?: string | undefined;
    }, {
        apiPath: string;
        token?: string | undefined;
    }>;
}, "strip", z.ZodTypeAny, {
    data: {
        new_password: string;
        old_password: string;
    };
    config: {
        apiPath: string;
        token?: string | undefined;
    };
    userId: string;
}, {
    data: {
        new_password: string;
        old_password: string;
    };
    config: {
        apiPath: string;
        token?: string | undefined;
    };
    userId: string;
}>;
type UpdatePasswordArgs = z.infer<typeof updatePasswordArgsSchema>;

declare const resetPasswordWithTokenArgsSchema: z.ZodObject<{
    userId: z.ZodString;
    data: z.ZodObject<{
        reset_token: z.ZodString;
        new_password: z.ZodString;
    }, "strip", z.ZodTypeAny, {
        reset_token: string;
        new_password: string;
    }, {
        reset_token: string;
        new_password: string;
    }>;
    config: z.ZodObject<{
        apiPath: z.ZodString;
        token: z.ZodOptional<z.ZodString>;
    }, "strip", z.ZodTypeAny, {
        apiPath: string;
        token?: string | undefined;
    }, {
        apiPath: string;
        token?: string | undefined;
    }>;
}, "strip", z.ZodTypeAny, {
    data: {
        reset_token: string;
        new_password: string;
    };
    config: {
        apiPath: string;
        token?: string | undefined;
    };
    userId: string;
}, {
    data: {
        reset_token: string;
        new_password: string;
    };
    config: {
        apiPath: string;
        token?: string | undefined;
    };
    userId: string;
}>;
type ResetPasswordWithTokenUserArgs = z.infer<typeof resetPasswordWithTokenArgsSchema>;

declare const resetPasswordArgsSchema: z.ZodObject<{
    userId: z.ZodString;
    config: z.ZodObject<{
        apiPath: z.ZodString;
        token: z.ZodOptional<z.ZodString>;
    }, "strip", z.ZodTypeAny, {
        apiPath: string;
        token?: string | undefined;
    }, {
        apiPath: string;
        token?: string | undefined;
    }>;
}, "strip", z.ZodTypeAny, {
    config: {
        apiPath: string;
        token?: string | undefined;
    };
    userId: string;
}, {
    config: {
        apiPath: string;
        token?: string | undefined;
    };
    userId: string;
}>;
type ResetUserArgs = z.infer<typeof resetPasswordArgsSchema>;

declare const createUserArgsSchema: z.ZodObject<{
    data: z.ZodObject<{
        description: z.ZodOptional<z.ZodString>;
        email: z.ZodString;
        fullname: z.ZodOptional<z.ZodString>;
        home_page: z.ZodOptional<z.ZodString>;
        location: z.ZodOptional<z.ZodString>;
        sendPasswordReset: z.ZodOptional<z.ZodBoolean>;
        username: z.ZodString;
        roles: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
        password: z.ZodOptional<z.ZodString>;
    }, "strip", z.ZodTypeAny, {
        username: string;
        email: string;
        description?: string | undefined;
        fullname?: string | undefined;
        home_page?: string | undefined;
        location?: string | undefined;
        sendPasswordReset?: boolean | undefined;
        roles?: string[] | undefined;
        password?: string | undefined;
    }, {
        username: string;
        email: string;
        description?: string | undefined;
        fullname?: string | undefined;
        home_page?: string | undefined;
        location?: string | undefined;
        sendPasswordReset?: boolean | undefined;
        roles?: string[] | undefined;
        password?: string | undefined;
    }>;
    config: z.ZodObject<{
        apiPath: z.ZodString;
        token: z.ZodOptional<z.ZodString>;
    }, "strip", z.ZodTypeAny, {
        apiPath: string;
        token?: string | undefined;
    }, {
        apiPath: string;
        token?: string | undefined;
    }>;
}, "strip", z.ZodTypeAny, {
    data: {
        username: string;
        email: string;
        description?: string | undefined;
        fullname?: string | undefined;
        home_page?: string | undefined;
        location?: string | undefined;
        sendPasswordReset?: boolean | undefined;