datocms-plugin-sdk 1.1.1 → 2.0.0

package/dist/types/hooks/mainNavigationTabs.d.ts

@@ -0,0 +1,43 @@
+import { Ctx } from '../ctx/base';
+import { Icon } from '../icon';
+export type MainNavigationTabsHook = {
+    /**
+     * Use this function to declare new tabs you want to add in the top-bar of the
+     * UI
+     *
+     * @tag pages
+     */
+    mainNavigationTabs: (ctx: Ctx) => MainNavigationTab[];
+};
+/** A tab to be displayed in the top-bar of the UI */
+export type MainNavigationTab = {
+    /** Label to be shown. Must be unique. */
+    label: string;
+    /**
+     * Icon to be shown alongside the label. Can be a FontAwesome icon name (ie.
+     * `"address-book"`) or a custom SVG definition. To maintain visual
+     * consistency with the rest of the interface, try to use FontAwesome icons
+     * whenever possible.
+     */
+    icon: Icon;
+    /** ID of the page linked to the tab */
+    pointsTo: {
+        pageId: string;
+    };
+    /**
+     * Expresses where you want to place the tab in the top-bar. If not specified,
+     * the tab will be placed after the standard tabs provided by DatoCMS itself.
+     */
+    placement?: [
+        'before' | 'after',
+        'content' | 'media' | 'schema' | 'configuration' | 'cdaPlayground'
+    ];
+    /**
+     * If different plugins specify the same `placement` for their tabs, they will
+     * be displayed by ascending `rank`. If you want to specify an explicit value
+     * for `rank`, make sure to offer a way for final users to customize it inside
+     * the plugin's settings form, otherwise the hardcoded value you choose might
+     * clash with the one of another plugin!
+     */
+    rank?: number;
+};

package/dist/types/hooks/manualFieldExtensions.d.ts

@@ -0,0 +1,58 @@
+import { Ctx } from '../ctx/base';
+export type ManualFieldExtensionsHook = {
+    /**
+     * Use this function to declare new field extensions that users will be able
+     * to install manually in some field
+     *
+     * @tag manualFieldExtensions
+     */
+    manualFieldExtensions: (ctx: Ctx) => ManualFieldExtension[];
+};
+export type ManualFieldExtension = {
+    /**
+     * ID of field extension. Will be the first argument for the
+     * `renderFieldExtension` function
+     */
+    id: string;
+    /** Name to be shown when editing fields */
+    name: string;
+    /**
+     * Type of field extension. An `editor` extension replaces the default field
+     * editor that DatoCMS provides, while an `addon` extension is placed
+     * underneath the field editor to provide additional info/behaviour. You can
+     * setup multiple field addons for every field.
+     */
+    type: FieldExtensionType;
+    /**
+     * For `editor` extensions: moves the field to the sidebar of the record
+     * editing page, mimicking a sidebar panel
+     */
+    asSidebarPanel?: boolean | {
+        startOpen: boolean;
+    };
+    /**
+     * The type of fields that the field extension in compatible with. You can use
+     * the shortcut `all` to target all types of fields
+     */
+    fieldTypes: 'all' | FieldType[];
+    /**
+     * Whether this field extension needs some configuration options before being
+     * installed in a field or not. Will trigger the
+     * `renderManualFieldExtensionConfigScreen` and
+     * `validateManualFieldExtensionParameters` methods
+     */
+    configurable?: boolean | {
+        initialHeight: number;
+    };
+    /**
+     * The initial height to set for the iframe that will render the field
+     * extension
+     */
+    initialHeight?: number;
+};
+/**
+ * The sidebar in the Content Area presents a number of user-defined menu-items.
+ * This object represents a new item to be added in the sidebar.
+ */
+export type FieldExtensionType = 'editor' | 'addon';
+export type FieldType = 'boolean' | 'color' | 'date_time' | 'date' | 'file' | 'float' | 'gallery' | 'integer' | 'json' | 'lat_lon' | 'link' | 'links' | 'rich_text' | 'seo' | 'slug' | 'string' | 'structured_text' | 'text' | 'video';

package/dist/types/hooks/onBeforeItemUpsert.d.ts

@@ -0,0 +1,15 @@
+import type { SchemaTypes } from '@datocms/cma-client';
+import { Ctx } from '../ctx/base';
+import { MaybePromise } from '../utils';
+type ItemUpdateSchema = SchemaTypes.ItemUpdateSchema;
+type ItemCreateSchema = SchemaTypes.ItemCreateSchema;
+export type OnBeforeItemUpsertHook = {
+    /**
+     * This function will be called before saving a new version of a record. You
+     * can stop the action by returning `false`
+     *
+     * @tag beforeHooks
+     */
+    onBeforeItemUpsert: (createOrUpdateItemPayload: ItemUpdateSchema | ItemCreateSchema, ctx: Ctx) => MaybePromise<boolean>;
+};
+export {};

package/dist/types/hooks/onBeforeItemsDestroy.d.ts

@@ -0,0 +1,14 @@
+import type { SchemaTypes } from '@datocms/cma-client';
+import { Ctx } from '../ctx/base';
+import { MaybePromise } from '../utils';
+type Item = SchemaTypes.Item;
+export type OnBeforeItemsDestroyHook = {
+    /**
+     * This function will be called before destroying records. You can stop the
+     * action by returning `false`
+     *
+     * @tag beforeHooks
+     */
+    onBeforeItemsDestroy: (items: Item[], ctx: Ctx) => MaybePromise<boolean>;
+};
+export {};

package/dist/types/hooks/onBeforeItemsPublish.d.ts

@@ -0,0 +1,14 @@
+import type { SchemaTypes } from '@datocms/cma-client';
+import { Ctx } from '../ctx/base';
+import { MaybePromise } from '../utils';
+type Item = SchemaTypes.Item;
+export type OnBeforeItemsPublishHook = {
+    /**
+     * This function will be called before publishing records. You can stop the
+     * action by returning `false`
+     *
+     * @tag beforeHooks
+     */
+    onBeforeItemsPublish: (items: Item[], ctx: Ctx) => MaybePromise<boolean>;
+};
+export {};

package/dist/types/hooks/onBeforeItemsUnpublish.d.ts

@@ -0,0 +1,14 @@
+import type { SchemaTypes } from '@datocms/cma-client';
+import { Ctx } from '../ctx/base';
+import { MaybePromise } from '../utils';
+type Item = SchemaTypes.Item;
+export type OnBeforeItemsUnpublishHook = {
+    /**
+     * This function will be called before unpublishing records. You can stop the
+     * action by returning `false`
+     *
+     * @tag beforeHooks
+     */
+    onBeforeItemsUnpublish: (items: Item[], ctx: Ctx) => MaybePromise<boolean>;
+};
+export {};

package/dist/types/hooks/onBoot.d.ts

@@ -0,0 +1,11 @@
+import { ImposedSizePluginFrameCtx } from '../ctx/pluginFrame';
+export type OnBootHook = {
+    /**
+     * This function will be called once at boot time and can be used to perform
+     * ie. some initial integrity checks on the configuration.
+     *
+     * @tag boot
+     */
+    onBoot: (ctx: OnBootCtx) => void;
+};
+export type OnBootCtx = ImposedSizePluginFrameCtx<'onBoot'>;

package/dist/types/hooks/overrideFieldExtensions.d.ts

@@ -0,0 +1,88 @@
+import type { SchemaTypes } from '@datocms/cma-client';
+import { Ctx } from '../ctx/base';
+import { ItemFormSidebarPanelPlacement } from '../shared';
+type Field = SchemaTypes.Field;
+type ItemType = SchemaTypes.ItemType;
+export type OverrideFieldExtensionsHook = {
+    /**
+     * Use this function to automatically force one or more field extensions to a
+     * particular field
+     *
+     * @tag forcedFieldExtensions
+     */
+    overrideFieldExtensions: (field: Field, ctx: OverrideFieldExtensionsHookCtx) => FieldExtensionOverride | undefined;
+};
+export type OverrideFieldExtensionsHookCtx = Ctx<{
+    itemType: ItemType;
+}>;
+/**
+ * An object expressing some field extensions you want to force on a particular
+ * field
+ */
+export type FieldExtensionOverride = {
+    /** Force a field editor/sidebar extension on a field */
+    editor?: EditorOverride;
+    /** One or more field sidebar extensions to forcefully add to a field */
+    addons?: AddonOverride[];
+};
+/** A field editor/sidebar forced on a field */
+export type EditorOverride = {
+    /**
+     * ID of field extension. Will be the first argument for the
+     * `renderFieldExtension` function
+     */
+    id: string;
+    /**
+     * Moves the field to the sidebar of the record editing page, mimicking a
+     * sidebar panel
+     */
+    asSidebarPanel?: boolean | {
+        startOpen?: boolean;
+        placement?: ItemFormSidebarPanelPlacement;
+    };
+    /**
+     * An arbitrary configuration object that will be passed as the `parameters`
+     * property of the second argument of the `renderFieldExtension` function
+     */
+    parameters?: Record<string, unknown>;
+    /**
+     * If multiple plugins override a field, the one with the lowest `rank` will
+     * win. If you want to specify an explicit value for `rank`, make sure to
+     * offer a way for final users to customize it inside the plugin's settings
+     * form, otherwise the hardcoded value you choose might clash with the one of
+     * another plugin!
+     */
+    rank?: number;
+    /**
+     * The initial height to set for the iframe that will render the field
+     * extension
+     */
+    initialHeight?: number;
+};
+/** A field addon extension forced on a field */
+export type AddonOverride = {
+    /**
+     * ID of field extension. Will be the first argument for the
+     * `renderFieldExtension` function
+     */
+    id: string;
+    /**
+     * An arbitrary configuration object that will be passed as the `parameters`
+     * property of the second argument of the `renderFieldExtension` function
+     */
+    parameters?: Record<string, unknown>;
+    /**
+     * If multiple addons are present for a field, they will be sorted by
+     * ascending `rank`. If you want to specify an explicit value for `rank`, make
+     * sure to offer a way for final users to customize it inside the plugin's
+     * settings form, otherwise the hardcoded value you choose might clash with
+     * the one of another plugin!
+     */
+    rank?: number;
+    /**
+     * The initial height to set for the iframe that will render the field
+     * extension
+     */
+    initialHeight?: number;
+};
+export {};

package/dist/types/hooks/renderAssetSource.d.ts

@@ -0,0 +1,98 @@
+import { SelfResizingPluginFrameCtx } from '../ctx/pluginFrame';
+export type RenderAssetSourceHook = {
+    /**
+     * This function will be called when the user selects one of the plugin's
+     * asset sources to upload a new media file.
+     *
+     * @tag assetSources
+     */
+    renderAssetSource: (assetSourceId: string, ctx: RenderAssetSourceCtx) => void;
+};
+export type RenderAssetSourceCtx = SelfResizingPluginFrameCtx<'renderAssetSource', {
+    /** The ID of the assetSource that needs to be rendered */
+    assetSourceId: string;
+}, {
+    /**
+     * Function to be called when the user selects the asset: it will trigger the
+     * creation of a new `Upload` that will be added in the Media Area.
+     *
+     * @example
+     *
+     * ```js
+     * await ctx.select({
+     *   resource: {
+     *     url: 'https://images.unsplash.com/photo-1416339306562-f3d12fefd36f',
+     *     filename: 'man-drinking-coffee.jpg',
+     *   },
+     *   copyright: 'Royalty free (Unsplash)',
+     *   author: 'Jeff Sheldon',
+     *   notes: 'A man drinking a coffee',
+     *   tags: ['man', 'coffee'],
+     * });
+     * ```
+     */
+    select: (newUpload: NewUpload) => void;
+}>;
+export type NewUploadResourceAsUrl = {
+    /**
+     * URL for the resource. The URL must respond with a
+     * `Access-Control-Allow-Origin` header — for instance `*`, which will allow
+     * all hosts — allowing the image to be read by DatoCMS
+     */
+    url: string;
+    /** Any additional headers to pass when making the request to the URL */
+    headers?: Record<string, string>;
+    /**
+     * Optional filename to be used to generate the final DatoCMS URL. If not
+     * passed, the URL will be used
+     */
+    filename?: string;
+};
+export type NewUploadResourceAsBase64 = {
+    /**
+     * Base64 encoded data URI for the resource.
+     *
+     * Format:
+     *
+     * `data:[<mime type>][;charset=<charset>];base64,<encoded data>`
+     */
+    base64: string;
+    /** Filename to be used to generate the final DatoCMS URL */
+    filename: string;
+};
+export type NewUpload = {
+    /** The actual resource that will be uploaded */
+    resource: NewUploadResourceAsUrl | NewUploadResourceAsBase64;
+    /** Copyright to apply to the asset */
+    copyright?: string;
+    /** Author to apply to the asset */
+    author?: string;
+    /** Notes to apply to the asset */
+    notes?: string;
+    /** Tags to apply to the asset */
+    tags?: string[];
+    /**
+     * An hash containing, for each locale of the project, the default metadata to
+     * apply to the asset
+     */
+    default_field_metadata?: {
+        [k: string]: {
+            /** Alternate text for the asset */
+            alt: string | null;
+            /** Title for the asset */
+            title: string | null;
+            /** Object with arbitrary metadata */
+            custom_data: {
+                [k: string]: unknown;
+            };
+            /** Focal point (only for image assets) */
+            focal_point?: {
+                /** Horizontal position expressed as float between 0 and 1 */
+                x: number;
+                /** Vertical position expressed as float between 0 and 1 */
+                y: number;
+            } | null;
+        };
+    };
+};
+export declare const renderAssetSourceBootstrapper: import("../utils").Bootstrapper<"renderAssetSource">;

package/dist/types/hooks/renderConfigScreen.d.ts

@@ -0,0 +1,12 @@
+import { SelfResizingPluginFrameCtx } from '../ctx/pluginFrame';
+export type RenderConfigScreenHook = {
+    /**
+     * This function will be called when the plugin needs to render the plugin's
+     * configuration form
+     *
+     * @tag configScreen
+     */
+    renderConfigScreen: (ctx: RenderConfigScreenCtx) => void;
+};
+export type RenderConfigScreenCtx = SelfResizingPluginFrameCtx<'renderConfigScreen'>;
+export declare const renderConfigScreenBootstrapper: import("../utils").Bootstrapper<"renderConfigScreen">;

package/dist/types/hooks/renderFieldExtension.d.ts

@@ -0,0 +1,20 @@
+import { FieldAdditionalProperties } from '../ctx/commonExtras/field';
+import { ItemFormAdditionalMethods, ItemFormAdditionalProperties } from '../ctx/commonExtras/itemForm';
+import { SelfResizingPluginFrameCtx } from '../ctx/pluginFrame';
+export type RenderFieldExtensionHook = {
+    /**
+     * This function will be called when the plugin needs to render a field
+     * extension (see the `manualFieldExtensions` and `overrideFieldExtensions`
+     * functions)
+     *
+     * @tag forcedFieldExtensions
+     */
+    renderFieldExtension: (fieldExtensionId: string, ctx: RenderFieldExtensionCtx) => void;
+};
+export type RenderFieldExtensionCtx = SelfResizingPluginFrameCtx<'renderFieldExtension', ItemFormAdditionalProperties & FieldAdditionalProperties & {
+    /** The ID of the field extension that needs to be rendered */
+    fieldExtensionId: string;
+    /** The arbitrary `parameters` of the field extension */
+    parameters: Record<string, unknown>;
+}, ItemFormAdditionalMethods>;
+export declare const renderFieldExtensionBootstrapper: import("../utils").Bootstrapper<"renderFieldExtension">;

package/dist/types/hooks/renderItemCollectionOutlet.d.ts

@@ -0,0 +1,9 @@
+import { SelfResizingPluginFrameCtx } from '../ctx/pluginFrame';
+export type RenderItemCollectionOutletHook = {
+    renderItemCollectionOutlet: (itemCollectionOutletId: string, ctx: RenderItemCollectionOutletCtx) => void;
+};
+export type RenderItemCollectionOutletCtx = SelfResizingPluginFrameCtx<'renderItemCollectionOutlet', {
+    /** The ID of the outlet that needs to be rendered */
+    itemCollectionOutletId: string;
+}>;
+export declare const renderItemCollectionOutletBootstrapper: import("../utils").Bootstrapper<"renderItemCollectionOutlet">;

package/dist/types/hooks/renderItemFormOutlet.d.ts

@@ -0,0 +1,16 @@
+import { ItemFormAdditionalMethods, ItemFormAdditionalProperties } from '../ctx/commonExtras/itemForm';
+import { SelfResizingPluginFrameCtx } from '../ctx/pluginFrame';
+export type RenderItemFormOutletHook = {
+    /**
+     * This function will be called when the plugin needs to render an outlet (see
+     * the `itemFormOutlets` function)
+     *
+     * @tag itemFormOutlets
+     */
+    renderItemFormOutlet: (itemFormOutletId: string, ctx: RenderItemFormOutletCtx) => void;
+};
+export type RenderItemFormOutletCtx = SelfResizingPluginFrameCtx<'renderItemFormOutlet', ItemFormAdditionalProperties & {
+    /** The ID of the outlet that needs to be rendered */
+    itemFormOutletId: string;
+}, ItemFormAdditionalMethods>;
+export declare const renderItemFormOutletBootstrapper: import("../utils").Bootstrapper<"renderItemFormOutlet">;

package/dist/types/hooks/renderItemFormSidebar.d.ts

@@ -0,0 +1,21 @@
+import { ItemFormAdditionalMethods, ItemFormAdditionalProperties } from '../ctx/commonExtras/itemForm';
+import { ImposedSizePluginFrameCtx } from '../ctx/pluginFrame';
+export type RenderItemFormSidebarHook = {
+    /**
+     * This function will be called when the plugin needs to render a sidebar (see
+     * the `itemFormSidebars` function)
+     *
+     * @tag sidebarPanels
+     */
+    renderItemFormSidebar: (sidebarId: string, ctx: RenderItemFormSidebarCtx) => void;
+};
+export type RenderItemFormSidebarCtx = ImposedSizePluginFrameCtx<'renderItemFormSidebar', ItemFormAdditionalProperties & {
+    /** The ID of the sidebar that needs to be rendered */
+    sidebarId: string;
+    /**
+     * The arbitrary `parameters` of the declared in the `itemFormSidebars`
+     * function
+     */
+    parameters: Record<string, unknown>;
+}, ItemFormAdditionalMethods>;
+export declare const renderItemFormSidebarBootstrapper: import("../utils").Bootstrapper<"renderItemFormSidebar">;

package/dist/types/hooks/renderItemFormSidebarPanel.d.ts

@@ -0,0 +1,21 @@
+import { ItemFormAdditionalMethods, ItemFormAdditionalProperties } from '../ctx/commonExtras/itemForm';
+import { SelfResizingPluginFrameCtx } from '../ctx/pluginFrame';
+export type RenderItemFormSidebarPanelHook = {
+    /**
+     * This function will be called when the plugin needs to render a sidebar panel
+     * (see the `itemFormSidebarPanels` function)
+     *
+     * @tag sidebarPanels
+     */
+    renderItemFormSidebarPanel: (sidebarPaneId: string, ctx: RenderItemFormSidebarPanelCtx) => void;
+};
+export type RenderItemFormSidebarPanelCtx = SelfResizingPluginFrameCtx<'renderItemFormSidebarPanel', ItemFormAdditionalProperties & {
+    /** The ID of the sidebar panel that needs to be rendered */
+    sidebarPaneId: string;
+    /**
+     * The arbitrary `parameters` of the panel declared in the
+     * `itemFormSidebarPanels` function
+     */
+    parameters: Record<string, unknown>;
+}, ItemFormAdditionalMethods>;
+export declare const renderItemFormSidebarPanelBootstrapper: import("../utils").Bootstrapper<"renderItemFormSidebarPanel">;

package/dist/types/hooks/renderManualFieldExtensionConfigScreen.d.ts

@@ -0,0 +1,55 @@
+import type { SchemaTypes } from '@datocms/cma-client';
+import { SelfResizingPluginFrameCtx } from '../ctx/pluginFrame';
+type Field = SchemaTypes.Field;
+type ItemType = SchemaTypes.ItemType;
+export type RenderManualFieldExtensionConfigScreenHook = {
+    renderManualFieldExtensionConfigScreen: (fieldExtensionId: string, ctx: RenderManualFieldExtensionConfigScreenCtx) => void;
+};
+export type RenderManualFieldExtensionConfigScreenCtx = SelfResizingPluginFrameCtx<'renderManualFieldExtensionConfigScreen', {
+    /**
+     * The ID of the field extension for which we need to render the parameters
+     * form
+     */
+    fieldExtensionId: string;
+    /**
+     * The current value of the parameters (you can change the value with the
+     * `setParameters` function)
+     */
+    parameters: Record<string, unknown>;
+    /**
+     * The current validation errors for the parameters (you can set them
+     * implementing the `validateManualFieldExtensionParameters` function)
+     */
+    errors: Record<string, unknown>;
+    /** The field entity that is being edited in the form */
+    pendingField: PendingField;
+    /** The model for the field being edited */
+    itemType: ItemType;
+}, {
+    /**
+     * Sets a new value for the parameters
+     *
+     * @example
+     *
+     * ```js
+     * await ctx.setParameters({ color: '#ff0000' });
+     * ```
+     */
+    setParameters: (params: Record<string, unknown>) => Promise<void>;
+}>;
+export type PendingField = {
+    id?: string;
+    type: 'field';
+    attributes: {
+        api_key: Field['attributes']['api_key'];
+        appearance: Field['attributes']['appearance'];
+        default_value: Field['attributes']['default_value'];
+        field_type: Field['attributes']['field_type'];
+        hint: Field['attributes']['hint'];
+        label: Field['attributes']['label'];
+        localized: Field['attributes']['localized'];
+        validators: Field['attributes']['validators'];
+    };
+};
+export declare const renderManualFieldExtensionConfigScreenBootstrapper: import("../utils").Bootstrapper<"renderManualFieldExtensionConfigScreen">;
+export {};

package/dist/types/hooks/renderModal.d.ts

@@ -0,0 +1,37 @@
+import { SelfResizingPluginFrameCtx } from '../ctx/pluginFrame';
+export type RenderModalHook = {
+    /**
+     * This function will be called when the plugin requested to open a modal (see
+     * the `openModal` function)
+     *
+     * @tag modals
+     */
+    renderModal: (modalId: string, ctx: RenderModalCtx) => void;
+};
+export type RenderModalCtx = SelfResizingPluginFrameCtx<'renderModal', {
+    /** The ID of the modal that needs to be rendered */
+    modalId: string;
+    /**
+     * The arbitrary `parameters` of the modal declared in the `openModal`
+     * function
+     */
+    parameters: Record<string, unknown>;
+}, {
+    /**
+     * A function to be called by the plugin to close the modal. The `openModal`
+     * call will be resolved with the passed return value
+     *
+     * @example
+     *
+     * ```js
+     * const returnValue = prompt(
+     *   'Please specify the value to return to the caller:',
+     *   'success',
+     * );
+     *
+     * await ctx.resolve(returnValue);
+     * ```
+     */
+    resolve: (returnValue: unknown) => Promise<void>;
+}>;
+export declare const renderModalBootstrapper: import("../utils").Bootstrapper<"renderModal">;

package/dist/types/hooks/renderPage.d.ts

@@ -0,0 +1,16 @@
+import { ImposedSizePluginFrameCtx } from '../ctx/pluginFrame';
+export type RenderPageHook = {
+    /**
+     * This function will be called when the plugin needs to render a specific
+     * page (see the `mainNavigationTabs`, `settingsAreaSidebarItemGroups` and
+     * `contentAreaSidebarItems` functions)
+     *
+     * @tag pages
+     */
+    renderPage: (pageId: string, ctx: RenderPageCtx) => void;
+};
+export type RenderPageCtx = ImposedSizePluginFrameCtx<'renderPage', {
+    /** The ID of the page that needs to be rendered */
+    pageId: string;
+}>;
+export declare const renderPageBootstrapper: import("../utils").Bootstrapper<"renderPage">;

package/dist/types/hooks/renderUploadSidebar.d.ts

@@ -0,0 +1,25 @@
+import type { SchemaTypes } from '@datocms/cma-client';
+import { ImposedSizePluginFrameCtx } from '../ctx/pluginFrame';
+type Upload = SchemaTypes.Upload;
+export type RenderUploadSidebarHook = {
+    /**
+     * This function will be called when the plugin needs to render a sidebar (see
+     * the `uploadSidebars` function)
+     *
+     * @tag sidebarPanels
+     */
+    renderUploadSidebar: (sidebarId: string, ctx: RenderUploadSidebarCtx) => void;
+};
+export type RenderUploadSidebarCtx = ImposedSizePluginFrameCtx<'renderUploadSidebar', {
+    /** The ID of the sidebar that needs to be rendered */
+    sidebarId: string;
+    /**
+     * The arbitrary `parameters` of the declared in the `uploadSidebars`
+     * function
+     */
+    parameters: Record<string, unknown>;
+    /** The active asset */
+    upload: Upload;
+}>;
+export declare const renderUploadSidebarBootstrapper: import("../utils").Bootstrapper<"renderUploadSidebar">;
+export {};

package/dist/types/hooks/renderUploadSidebarPanel.d.ts

@@ -0,0 +1,25 @@
+import { SchemaTypes } from '@datocms/cma-client';
+import { SelfResizingPluginFrameCtx } from '../ctx/pluginFrame';
+type Upload = SchemaTypes.Upload;
+export type RenderUploadSidebarPanelHook = {
+    /**
+     * This function will be called when the plugin needs to render a sidebar panel
+     * (see the `uploadSidebarPanels` function)
+     *
+     * @tag sidebarPanels
+     */
+    renderUploadSidebarPanel: (sidebarPaneId: string, ctx: RenderUploadSidebarPanelCtx) => void;
+};
+export type RenderUploadSidebarPanelCtx = SelfResizingPluginFrameCtx<'renderUploadSidebarPanel', {
+    /** The ID of the sidebar panel that needs to be rendered */
+    sidebarPaneId: string;
+    /**
+     * The arbitrary `parameters` of the panel declared in the
+     * `uploadSidebarPanels` function
+     */
+    parameters: Record<string, unknown>;
+    /** The active asset */
+    upload: Upload;
+}>;
+export declare const renderUploadSidebarPanelBootstrapper: import("../utils").Bootstrapper<"renderUploadSidebarPanel">;
+export {};