import type { ConfigDelegate } from './config-delegate';
import type { DocumentWithSource } from './content-source-document';
import type { DocumentField, DocumentObjectField, DocumentModelField } from './content-source-document-fields';
import type { ModelWithSource, ObjectModel } from './models';
import type { ClientField, FieldPath } from './model-fields';
import type { User } from './content-source';
import type { DocumentHookBaseOptions } from './config';
import type { Field, FieldBoolean, FieldColor, FieldDate, FieldDatetime, FieldEnum, FieldHtml, FieldMarkdown, FieldModel, FieldNumber, FieldObject, FieldReference, FieldSlug, FieldString, FieldText, FieldUrl } from './model-fields';
import { ICONS } from './consts';
import { ContentSourceActions } from './config';
import { DistributiveOmit } from './utility-types';
export interface CustomActionCommonParams {
    name: string;
    label?: string;
    icon?: (typeof ICONS)[number];
    hidden?: boolean;
    preferredStyle?: 'button-primary' | 'button-secondary';
    inputFields?: CustomActionInputField[];
}
export interface CustomActionGlobal extends CustomActionCommonParams {
    type: 'global';
    state?: CustomActionStateFunction;
    run: CustomActionRunFunction;
    permissions?: CustomActionPermissionsFunction;
}
export interface CustomActionBulk extends CustomActionCommonParams {
    type: 'bulk';
    state?: CustomActionStateFunction;
    run: CustomActionRunFunction<{
        documents: DocumentWithSource[];
    }>;
    permissions?: CustomActionPermissionsFunction;
}
export interface CustomActionModel extends CustomActionCommonParams {
    type: 'model';
    run: CustomActionRunFunction<CustomActionModelRunOptions>;
    permissions?: CustomActionPermissionsFunction;
    /**
     * Lists model names for which the action is shown in the visual editor.
     * Applicable only for actions defined in the stackbit config's root action array.
     */
    models?: string[];
    locations?: ('new-card' | 'preset-card')[];
}
export interface CustomActionModelRunOptions {
    /** The selected model for the action. */
    actionModel: ModelWithSource;
    /** The {@link ContentSourceActions} for the content source of the given `actionModel` */
    contentSourceActions: ContentSourceActions;
    /**
     * The location in UI where the action was triggered.
     * The 'preset-card' will be set when the user triggers the action from a
     * preset. In this case the `inputData.presetData` will contain the data of
     * the selected preset.
     * The 'new-card' will be set when the user triggers the action not from a preset.
     */
    location: 'new-card' | 'preset-card';
}
export interface CustomActionDocument extends CustomActionCommonParams {
    type?: 'document';
    state?: CustomActionStateFunction<CustomActionDocumentStateOptions>;
    run: CustomActionRunFunction<CustomActionDocumentRunOptions>;
    permissions?: CustomActionPermissionsFunction<CustomActionDocumentStateOptions>;
}
export interface CustomActionDocumentStateOptions {
    document: DocumentWithSource;
    model: ModelWithSource;
}
export interface CustomActionDocumentRunOptions extends CustomActionDocumentStateOptions {
    contentSourceActions: ContentSourceActions;
}
/**
 * Custom action that runs in the context of an "object" model, within an existing document.
 * This action can be used to create new nested objects within an existing document.
 */
export interface CustomActionModelObject extends CustomActionCommonParams {
    type: 'model';
    run: CustomActionRunFunction<CustomActionModelObjectRunOptions>;
    permissions?: CustomActionPermissionsFunction;
    locations?: ('new-card' | 'preset-card')[];
}
export interface CustomActionModelObjectRunOptions {
    parentDocument: DocumentWithSource;
    parentModel: ModelWithSource;
    modelField: FieldModel;
    fieldPath: FieldPath;
    objectModel: ModelWithSource<ObjectModel>;
    location: 'new-card' | 'preset-card';
    contentSourceActions: ContentSourceActions;
}
/**
 * Custom action that runs in the context of a nested object represented by a model of type "object".
 * This action can be used to update an existing nested object within an existing document.
 */
export interface CustomActionObjectModel extends CustomActionCommonParams {
    type?: 'object';
    state?: CustomActionStateFunction<CustomActionObjectModelStateParams>;
    run: CustomActionRunFunction<CustomActionObjectModelRunParams>;
    permissions?: CustomActionPermissionsFunction<CustomActionObjectModelStateParams>;
}
export interface CustomActionObjectModelStateParams {
    parentDocument: DocumentWithSource;
    parentModel: ModelWithSource;
    documentField: DocumentModelField;
    modelField: FieldModel;
    fieldPath: FieldPath;
    objectModel: ModelWithSource<ObjectModel>;
}
export interface CustomActionObjectModelRunParams extends CustomActionObjectModelStateParams {
    contentSourceActions: ContentSourceActions;
}
export interface CustomActionObjectField extends CustomActionCommonParams {
    type: 'object';
    state?: CustomActionStateFunction<CustomActionObjectFieldStateParams>;
    run: CustomActionRunFunction<CustomActionObjectFieldRunParams>;
    permissions?: CustomActionPermissionsFunction<CustomActionObjectFieldStateParams>;
}
export interface CustomActionObjectFieldStateParams {
    parentDocument: DocumentWithSource;
    parentModel: ModelWithSource;
    documentField: DocumentObjectField;
    modelField: FieldObject;
    fieldPath: FieldPath;
}
export interface CustomActionObjectFieldRunParams extends CustomActionObjectFieldStateParams {
    contentSourceActions: ContentSourceActions;
}
export interface CustomActionField extends CustomActionCommonParams {
    type?: 'field';
    state?: CustomActionStateFunction<CustomActionFieldStateParams>;
    run: CustomActionRunFunction<CustomActionFieldRunParams>;
    permissions?: CustomActionPermissionsFunction<CustomActionFieldStateParams>;
}
export interface CustomActionFieldStateParams {
    parentDocument: DocumentWithSource;
    parentModel: ModelWithSource;
    documentField?: DocumentField;
    modelField: Field;
    fieldPath: FieldPath;
}
export interface CustomActionFieldRunParams extends CustomActionFieldStateParams {
    contentSourceActions: ContentSourceActions;
}
export type CustomActionState = 'enabled' | 'running' | 'disabled';
export type CustomActionStateFunction<T = unknown> = (options: CustomActionStateCommonOptions & T) => Promise<CustomActionState>;
export interface CustomActionStateCommonOptions extends ConfigDelegate {
    actionId: string;
    currentLocale?: string;
    currentUser?: User;
    currentPageUrl?: string;
    currentPageDocument?: DocumentWithSource;
}
/**
 * The `run` function runs the action that was triggered in the visual editor.
 * This function should return a promise.
 *
 * If this function resolves with `undefined` value, the action is considered to
 * have completed successfully. This function may also resolve with the
 * {@link CustomActionResult} object to show "success" or "fail" messages in the
 * visual editor.
 */
export type CustomActionRunFunction<T = unknown> = (options: CustomActionRunCommonOptions & T) => Promise<CustomActionResult | void>;
export interface CustomActionRunCommonOptions extends ConfigDelegate, Pick<DocumentHookBaseOptions, 'getContentSourceActionsForSource' | 'getUserContextForContentSourceType'> {
    actionId: string;
    inputData?: Record<string, any>;
    progress: CustomActionProgressFunction;
    currentLocale?: string;
    currentUser?: User;
    currentPageUrl?: string;
    currentPageDocument?: DocumentWithSource;
}
export type CustomActionProgressFunction = (options: {
    message?: string;
    percent?: number;
}) => void;
export interface CustomActionResult {
    /** @deprecated */
    state?: CustomActionState;
    /**
     * If the result object contains the `success` property, the action is
     * considered to have completed successfully, and the value of the `success`
     * property will be shown in the visual editor as a success message.
     */
    success?: string;
    /**
     * If the result object contains the `error` property, the action is
     * considered to have failed, and the value of the `error` property will be
     * shown in the visual editor as an error message.
     */
    error?: string;
    /**
     * When the action is triggered programmatically from within a custom field,
     * it may return a `result` value. This value will be returned from the
     * {@link CustomControlWindow.stackbit.runAction} function called from the
     * custom field.
     *
     * @see FieldCustomControlTypeProps
     * @see CustomControlWindow
     */
    result?: any;
}
export type CustomActionPermissionsFunction<T = unknown> = (options: CustomActionPermissionsCommonOptions & T) => CustomActionPermissions | undefined;
export type CustomActionPermissions = {
    canExecute?: boolean;
};
export interface CustomActionPermissionsCommonOptions extends ConfigDelegate {
    actionId: string;
    currentLocale?: string;
    userContext: User;
    currentPageUrl?: string;
    currentPageDocument?: DocumentWithSource;
}
export type CustomActionClientModel<T extends CustomActionModel | CustomActionDocument | CustomActionModelObject | CustomActionObjectModel | CustomActionField> = Omit<T, 'permissions' | 'run' | 'state' | 'inputFields'> & {
    inputFields?: CustomActionInputClientField[];
};
export type CustomActionInputField = DistributiveOmit<FieldString | FieldUrl | FieldSlug | FieldText | FieldMarkdown | FieldHtml | FieldNumber | FieldBoolean | FieldDate | FieldDatetime | FieldColor | FieldEnum | FieldReference, 'actions'>;
export type CustomActionInputClientField = ClientField<CustomActionInputField>;
//# sourceMappingURL=custom-actions.d.ts.map