@contentful/field-editor-reference 5.9.0 → 5.11.0

package/dist/{assets → types/assets}/WrappedAssetCard/WrappedAssetLink.d.ts

@@ -1,16 +1,16 @@
-/// <reference types="react" />
-import { SpaceAPI } from '@contentful/field-editor-shared';
-import { Asset, RenderDragFn } from '../../types';
-export interface WrappedAssetLinkProps {
-    getEntityScheduledActions: SpaceAPI['getEntityScheduledActions'];
-    asset: Asset;
-    localeCode: string;
-    defaultLocaleCode: string;
-    href?: string;
-    className?: string;
-    isDisabled: boolean;
-    onEdit: () => void;
-    onRemove: () => void;
-    renderDragHandle?: RenderDragFn;
-}
-export declare const WrappedAssetLink: (props: WrappedAssetLinkProps) => JSX.Element;
+import * as React from 'react';
+import { SpaceAPI } from '@contentful/field-editor-shared';
+import { Asset, RenderDragFn } from '../../types';
+export interface WrappedAssetLinkProps {
+    getEntityScheduledActions: SpaceAPI['getEntityScheduledActions'];
+    asset: Asset;
+    localeCode: string;
+    defaultLocaleCode: string;
+    href?: string;
+    className?: string;
+    isDisabled: boolean;
+    onEdit: () => void;
+    onRemove: () => void;
+    renderDragHandle?: RenderDragFn;
+}
+export declare const WrappedAssetLink: (props: WrappedAssetLinkProps) => React.JSX.Element;

package/dist/{assets → types/assets}/index.d.ts

@@ -1,3 +1,3 @@
-export { SingleMediaEditor } from './SingleMediaEditor';
-export { MultipleMediaEditor } from './MultipleMediaEditor';
-export { WrappedAssetCard } from './WrappedAssetCard/WrappedAssetCard';
+export { SingleMediaEditor } from './SingleMediaEditor';
+export { MultipleMediaEditor } from './MultipleMediaEditor';
+export { WrappedAssetCard } from './WrappedAssetCard/WrappedAssetCard';

package/dist/{common → types/common}/EntityStore.d.ts

@@ -1,62 +1,62 @@
-import React from 'react';
-import { BaseExtensionSDK } from '@contentful/app-sdk';
-import { Asset, ContentType, Entry, Resource, ResourceType, Space, ScheduledAction } from '../types';
-export declare type ResourceInfo<R extends Resource = Resource> = {
-    resource: R;
-    defaultLocaleCode: string;
-    contentType: ContentType;
-    space: Space;
-};
-declare type EntityStoreProps = {
-    sdk: BaseExtensionSDK;
-    queryConcurrency?: number;
-};
-declare type GetOptions = {
-    priority?: number;
-};
-declare type GetEntityOptions = GetOptions & {
-    spaceId?: string;
-    environmentId?: string;
-};
-declare type UseEntityOptions = GetEntityOptions & {
-    enabled?: boolean;
-};
-declare type QueryEntityResult<E> = Promise<E>;
-declare type GetResourceOptions = GetOptions;
-declare type QueryResourceResult<R extends Resource = Resource> = QueryEntityResult<ResourceInfo<R>>;
-declare type UseResourceOptions = GetResourceOptions & {
-    enabled?: boolean;
-};
-declare type UseEntityResult<E> = {
-    status: 'idle';
-    data: never;
-} | {
-    status: 'loading';
-    data: never;
-} | {
-    status: 'error';
-    data: never;
-} | {
-    status: 'success';
-    data: E;
-};
-declare type FetchableEntityType = 'Entry' | 'Asset';
-declare type FetchableEntity = Entry | Asset;
-export declare class UnsupportedError extends Error {
-    isUnsupportedError: boolean;
-    constructor(message: string);
-}
-export declare function isUnsupportedError(value: unknown): value is UnsupportedError;
-declare const useEntityLoader: () => {
-    getResource: <R extends Resource = Resource>(resourceType: ResourceType, urn: string, options?: GetOptions | undefined) => QueryResourceResult<R>;
-    getEntity: <E extends FetchableEntity>(entityType: FetchableEntityType, entityId: string, options?: GetEntityOptions | undefined) => QueryEntityResult<E>;
-    getEntityScheduledActions: (entityType: FetchableEntityType, entityId: string, options?: GetEntityOptions | undefined) => QueryEntityResult<ScheduledAction[]>;
-};
-export declare function useEntity<E extends FetchableEntity>(entityType: FetchableEntityType, entityId: string, options?: UseEntityOptions): UseEntityResult<E>;
-export declare function useResource(resourceType: ResourceType, urn: string, options?: UseResourceOptions): {
-    status: "loading" | "error" | "success";
-    data: ResourceInfo<Resource> | undefined;
-    error: unknown;
-};
-declare function EntityProvider({ children, ...props }: React.PropsWithChildren<EntityStoreProps>): JSX.Element;
-export { EntityProvider, useEntityLoader };
+import React from 'react';
+import { BaseExtensionSDK } from '@contentful/app-sdk';
+import { Asset, ContentType, Entry, Resource, ResourceType, ScheduledAction, Space } from '../types';
+export type ResourceInfo<R extends Resource = Resource> = {
+    resource: R;
+    defaultLocaleCode: string;
+    contentType: ContentType;
+    space: Space;
+};
+type EntityStoreProps = {
+    sdk: BaseExtensionSDK;
+    queryConcurrency?: number;
+};
+type GetOptions = {
+    priority?: number;
+};
+type GetEntityOptions = GetOptions & {
+    spaceId?: string;
+    environmentId?: string;
+};
+type UseEntityOptions = GetEntityOptions & {
+    enabled?: boolean;
+};
+type QueryEntityResult<E> = Promise<E>;
+type GetResourceOptions = GetOptions;
+type QueryResourceResult<R extends Resource = Resource> = QueryEntityResult<ResourceInfo<R>>;
+type UseResourceOptions = GetResourceOptions & {
+    enabled?: boolean;
+};
+type UseEntityResult<E> = {
+    status: 'idle';
+    data: never;
+} | {
+    status: 'loading';
+    data: never;
+} | {
+    status: 'error';
+    data: never;
+} | {
+    status: 'success';
+    data: E;
+};
+type FetchableEntityType = 'Entry' | 'Asset';
+type FetchableEntity = Entry | Asset;
+export declare class UnsupportedError extends Error {
+    isUnsupportedError: boolean;
+    constructor(message: string);
+}
+export declare function isUnsupportedError(value: unknown): value is UnsupportedError;
+declare const useEntityLoader: () => {
+    getResource: <R extends Resource = Resource>(resourceType: ResourceType, urn: string, options?: GetResourceOptions) => QueryResourceResult<R>;
+    getEntity: <E extends FetchableEntity>(entityType: FetchableEntityType, entityId: string, options?: GetEntityOptions) => QueryEntityResult<E>;
+    getEntityScheduledActions: (entityType: FetchableEntityType, entityId: string, options?: GetEntityOptions) => QueryEntityResult<ScheduledAction[]>;
+};
+export declare function useEntity<E extends FetchableEntity>(entityType: FetchableEntityType, entityId: string, options?: UseEntityOptions): UseEntityResult<E>;
+export declare function useResource(resourceType: ResourceType, urn: string, options?: UseResourceOptions): {
+    status: "loading" | "error" | "success";
+    data: ResourceInfo<Resource> | undefined;
+    error: unknown;
+};
+declare function EntityProvider({ children, ...props }: React.PropsWithChildren<EntityStoreProps>): React.JSX.Element;
+export { EntityProvider, useEntityLoader };

package/dist/{common → types/common}/MultipleReferenceEditor.d.ts

@@ -1,25 +1,25 @@
-import * as React from 'react';
-import { SortEndHandler, SortStartHandler } from 'react-sortable-hoc';
-import { ReferenceValue, ContentEntityType, ContentType } from '../types';
-import { ReferenceEditorProps } from './ReferenceEditor';
-declare type ChildProps = {
-    entityType: ContentEntityType;
-    items: ReferenceValue[];
-    isDisabled: boolean;
-    setValue: (value: ReferenceValue[]) => void;
-    allContentTypes: ContentType[];
-    onSortStart: SortStartHandler;
-    onSortEnd: SortEndHandler;
-    onMove: (oldIndex: number, newIndex: number) => void;
-};
-export declare function MultipleReferenceEditor(props: ReferenceEditorProps & {
-    entityType: ContentEntityType;
-    children: (props: ReferenceEditorProps & ChildProps) => React.ReactElement;
-    setIndexToUpdate?: React.Dispatch<React.SetStateAction<number | undefined>>;
-}): JSX.Element;
-export declare namespace MultipleReferenceEditor {
-    var defaultProps: {
-        hasCardEditActions: boolean;
-    };
-}
-export {};
+import * as React from 'react';
+import { SortEndHandler, SortStartHandler } from 'react-sortable-hoc';
+import { ReferenceValue, ContentEntityType, ContentType } from '../types';
+import { ReferenceEditorProps } from './ReferenceEditor';
+type ChildProps = {
+    entityType: ContentEntityType;
+    items: ReferenceValue[];
+    isDisabled: boolean;
+    setValue: (value: ReferenceValue[]) => void;
+    allContentTypes: ContentType[];
+    onSortStart: SortStartHandler;
+    onSortEnd: SortEndHandler;
+    onMove: (oldIndex: number, newIndex: number) => void;
+};
+export declare function MultipleReferenceEditor(props: ReferenceEditorProps & {
+    entityType: ContentEntityType;
+    children: (props: ReferenceEditorProps & ChildProps) => React.ReactElement;
+    setIndexToUpdate?: React.Dispatch<React.SetStateAction<number | undefined>>;
+}): React.JSX.Element;
+export declare namespace MultipleReferenceEditor {
+    var defaultProps: {
+        hasCardEditActions: boolean;
+    };
+}
+export {};

package/dist/{common → types/common}/ReferenceEditor.d.ts

@@ -1,46 +1,46 @@
-import * as React from 'react';
-import { FieldConnector } from '@contentful/field-editor-shared';
-import type { LinkActionsProps } from '../components';
-import { Action, ActionLabels, FieldExtensionSDK, ViewType } from '../types';
-import { CustomCardRenderer, RenderCustomMissingEntityCard } from './customCardTypes';
-export interface ReferenceEditorProps {
-    /**
-     * Whether or not the field should be disabled initially.
-     */
-    isInitiallyDisabled: boolean;
-    hasCardEditActions: boolean;
-    hasCardMoveActions?: boolean;
-    hasCardRemoveActions?: boolean;
-    sdk: FieldExtensionSDK;
-    viewType: ViewType;
-    renderCustomCard?: CustomCardRenderer;
-    renderCustomActions?: (props: CustomActionProps) => React.ReactElement;
-    renderCustomMissingEntityCard?: RenderCustomMissingEntityCard;
-    getEntityUrl?: (entryId: string) => string;
-    onAction?: (action: Action) => void;
-    actionLabels?: Partial<ActionLabels>;
-    parameters: {
-        instance: {
-            showCreateEntityAction?: boolean;
-            showLinkEntityAction?: boolean;
-            bulkEditing?: boolean;
-        };
-    };
-    updateBeforeSortStart?: ({ index }: {
-        index: number;
-    }) => void;
-    onSortingEnd?: ({ oldIndex, newIndex }: {
-        oldIndex: number;
-        newIndex: number;
-    }) => void;
-}
-export declare type CustomActionProps = LinkActionsProps;
-export declare function ReferenceEditor<T>(props: ReferenceEditorProps & {
-    children: FieldConnector<T>['props']['children'];
-}): JSX.Element;
-export declare namespace ReferenceEditor {
-    var defaultProps: {
-        isInitiallyDisabled: boolean;
-        hasCardEditActions: boolean;
-    };
-}
+import * as React from 'react';
+import { FieldConnector } from '@contentful/field-editor-shared';
+import type { LinkActionsProps } from '../components';
+import { Action, ActionLabels, FieldExtensionSDK, ViewType } from '../types';
+import { CustomCardRenderer, RenderCustomMissingEntityCard } from './customCardTypes';
+export interface ReferenceEditorProps {
+    /**
+     * Whether or not the field should be disabled initially.
+     */
+    isInitiallyDisabled: boolean;
+    hasCardEditActions: boolean;
+    hasCardMoveActions?: boolean;
+    hasCardRemoveActions?: boolean;
+    sdk: FieldExtensionSDK;
+    viewType: ViewType;
+    renderCustomCard?: CustomCardRenderer;
+    renderCustomActions?: (props: CustomActionProps) => React.ReactElement;
+    renderCustomMissingEntityCard?: RenderCustomMissingEntityCard;
+    getEntityUrl?: (entryId: string) => string;
+    onAction?: (action: Action) => void;
+    actionLabels?: Partial<ActionLabels>;
+    parameters: {
+        instance: {
+            showCreateEntityAction?: boolean;
+            showLinkEntityAction?: boolean;
+            bulkEditing?: boolean;
+        };
+    };
+    updateBeforeSortStart?: ({ index }: {
+        index: number;
+    }) => void;
+    onSortingEnd?: ({ oldIndex, newIndex }: {
+        oldIndex: number;
+        newIndex: number;
+    }) => void;
+}
+export type CustomActionProps = LinkActionsProps;
+export declare function ReferenceEditor<T>(props: ReferenceEditorProps & {
+    children: FieldConnector<T>['props']['children'];
+}): React.JSX.Element;
+export declare namespace ReferenceEditor {
+    var defaultProps: {
+        isInitiallyDisabled: boolean;
+        hasCardEditActions: boolean;
+    };
+}

package/dist/{common → types/common}/SingleReferenceEditor.d.ts

@@ -1,24 +1,24 @@
-import * as React from 'react';
-import { ContentType, ContentEntityType, ReferenceValue } from '../types';
-import { ReferenceEditorProps } from './ReferenceEditor';
-declare type ChildProps = {
-    entityId: string;
-    entityType: ContentEntityType;
-    isDisabled: boolean;
-    setValue: (value: ReferenceValue | null | undefined) => void;
-    allContentTypes: ContentType[];
-    renderCustomCard?: ReferenceEditorProps['renderCustomCard'];
-    hasCardEditActions: boolean;
-    hasCardRemoveActions?: boolean;
-};
-export declare function SingleReferenceEditor(props: ReferenceEditorProps & {
-    entityType: ContentEntityType;
-    children: (props: ChildProps) => React.ReactElement;
-}): JSX.Element;
-export declare namespace SingleReferenceEditor {
-    var defaultProps: {
-        hasCardEditActions: boolean;
-        hasCardRemoveActions: boolean;
-    };
-}
-export {};
+import * as React from 'react';
+import { ContentType, ContentEntityType, ReferenceValue } from '../types';
+import { ReferenceEditorProps } from './ReferenceEditor';
+type ChildProps = {
+    entityId: string;
+    entityType: ContentEntityType;
+    isDisabled: boolean;
+    setValue: (value: ReferenceValue | null | undefined) => void;
+    allContentTypes: ContentType[];
+    renderCustomCard?: ReferenceEditorProps['renderCustomCard'];
+    hasCardEditActions: boolean;
+    hasCardRemoveActions?: boolean;
+};
+export declare function SingleReferenceEditor(props: ReferenceEditorProps & {
+    entityType: ContentEntityType;
+    children: (props: ChildProps) => React.ReactElement;
+}): React.JSX.Element;
+export declare namespace SingleReferenceEditor {
+    var defaultProps: {
+        hasCardEditActions: boolean;
+        hasCardRemoveActions: boolean;
+    };
+}
+export {};

package/dist/{common → types/common}/SortableLinkList.d.ts

@@ -1,19 +1,19 @@
-import React from 'react';
-import { SortableContainerProps } from 'react-sortable-hoc';
-import { ReferenceEditorProps } from './ReferenceEditor';
-declare type SortableContainerChildProps<IType> = Pick<SortableLinkListProps<IType>, 'items' | 'isDisabled'> & {
-    item: IType;
-    index: number;
-    DragHandle?: typeof DragHandle;
-};
-declare type SortableLinkListProps<T> = ReferenceEditorProps & {
-    items: T[];
-    isDisabled: boolean;
-    children: (props: SortableContainerChildProps<T>) => React.ReactElement;
-    className?: string;
-};
-declare const DragHandle: (props: {
-    drag: React.ReactElement;
-}) => JSX.Element;
-export declare function SortableLinkList<T>(props: SortableLinkListProps<T> & SortableContainerProps): JSX.Element;
-export {};
+import * as React from 'react';
+import { SortableContainerProps } from 'react-sortable-hoc';
+import { ReferenceEditorProps } from './ReferenceEditor';
+type SortableContainerChildProps<IType> = Pick<SortableLinkListProps<IType>, 'items' | 'isDisabled'> & {
+    item: IType;
+    index: number;
+    DragHandle?: typeof DragHandle;
+};
+type SortableLinkListProps<T> = ReferenceEditorProps & {
+    items: T[];
+    isDisabled: boolean;
+    children: (props: SortableContainerChildProps<T>) => React.ReactElement;
+    className?: string;
+};
+declare const DragHandle: (props: {
+    drag: React.ReactElement;
+}) => React.JSX.Element;
+export declare function SortableLinkList<T>(props: SortableLinkListProps<T> & SortableContainerProps): React.JSX.Element;
+export {};

package/dist/{common → types/common}/customCardTypes.d.ts

@@ -1,29 +1,29 @@
-import * as React from 'react';
-import { Asset, ContentType, Entry, RenderDragFn } from '../types';
-import { CustomActionProps } from './ReferenceEditor';
-export declare type MissingEntityCardProps = {
-    defaultCard: React.ReactElement;
-    entity: {
-        id: string;
-        type: 'Asset' | 'Entry';
-    };
-};
-export declare type RenderCustomMissingEntityCard = ({ defaultCard, }: MissingEntityCardProps) => React.ReactElement;
-export declare type DefaultCardRenderer = (props?: CustomEntityCardProps) => React.ReactElement;
-export declare type CustomCardRenderer = (props: CustomEntityCardProps, linkActionsProps: CustomActionProps, renderDefaultCard: DefaultCardRenderer) => React.ReactElement | false;
-export declare type CustomEntityCardProps = {
-    entity: Entry | Asset;
-    entityUrl?: string;
-    contentType?: ContentType;
-    index?: number;
-    localeCode: string;
-    defaultLocaleCode: string;
-    isDisabled: boolean;
-    size: 'default' | 'small';
-    renderDragHandle?: RenderDragFn;
-    onEdit?: () => void;
-    onRemove?: () => void;
-    onMoveTop?: () => void;
-    onMoveBottom?: () => void;
-    isBeingDragged?: boolean;
-};
+import * as React from 'react';
+import { Asset, ContentType, Entry, RenderDragFn } from '../types';
+import { CustomActionProps } from './ReferenceEditor';
+export type MissingEntityCardProps = {
+    defaultCard: React.ReactElement;
+    entity: {
+        id: string;
+        type: 'Asset' | 'Entry';
+    };
+};
+export type RenderCustomMissingEntityCard = ({ defaultCard, }: MissingEntityCardProps) => React.ReactElement;
+export type DefaultCardRenderer = (props?: CustomEntityCardProps) => React.ReactElement;
+export type CustomCardRenderer = (props: CustomEntityCardProps, linkActionsProps: CustomActionProps, renderDefaultCard: DefaultCardRenderer) => React.ReactElement | false;
+export type CustomEntityCardProps = {
+    entity: Entry | Asset;
+    entityUrl?: string;
+    contentType?: ContentType;
+    index?: number;
+    localeCode: string;
+    defaultLocaleCode: string;
+    isDisabled: boolean;
+    size: 'default' | 'small';
+    renderDragHandle?: RenderDragFn;
+    onEdit?: () => void;
+    onRemove?: () => void;
+    onMoveTop?: () => void;
+    onMoveBottom?: () => void;
+    isBeingDragged?: boolean;
+};

package/dist/types/common/useAccessApi.d.ts

@@ -0,0 +1,16 @@
+import type { AccessAPI, ArchiveableAction, CrudAction, PublishableAction } from '@contentful/app-sdk';
+type EntryAction = CrudAction | PublishableAction | ArchiveableAction;
+type ExtendedAccessAPI = {
+    canPerformActionOnEntryOfType: (action: EntryAction, contentTypeId: string) => Promise<boolean>;
+};
+export declare function useAccessApi(accessApi: AccessAPI & Partial<ExtendedAccessAPI>): {
+    canPerformAction: {
+        (action: "read" | "update", entity: "EditorInterface" | import("@contentful/app-sdk").EditorInterface): Promise<boolean>;
+        <T = Object>(action: CrudAction, entity: import("@contentful/app-sdk").ContentType | "Entry" | "Asset" | "ContentType" | T): Promise<boolean>;
+        <T_1 = Object>(action: PublishableAction, entity: import("@contentful/app-sdk").ContentType | "Entry" | "Asset" | "ContentType" | T_1): Promise<boolean>;
+        <T_2 = Object>(action: ArchiveableAction, entity: "Entry" | "Asset" | T_2): Promise<boolean>;
+        (action: "update", entity: import("@contentful/app-sdk").Entry | import("@contentful/app-sdk").Asset | import("@contentful/app-sdk").Task | import("@contentful/app-sdk").WorkflowDefinition, patch: import("@contentful/app-sdk").JSONPatchItem[]): Promise<boolean>;
+    };
+    canPerformActionOnEntryOfType: (action: EntryAction, contentTypeId: string) => Promise<boolean>;
+};
+export {};

package/dist/{common → types/common}/useContentTypePermissions.d.ts

@@ -1,17 +1,17 @@
-import { ContentType, ContentEntityType, FieldExtensionSDK } from '../types';
-import { ReferenceValidations } from '../utils/fromFieldValidations';
-import { ReferenceEditorProps } from './ReferenceEditor';
-declare type ContentTypePermissionsProps = {
-    sdk: FieldExtensionSDK;
-    entityType: ContentEntityType;
-    parameters: ReferenceEditorProps['parameters'];
-    allContentTypes: ContentType[];
-    validations: ReferenceValidations;
-};
-declare type ContentTypePermissions = {
-    creatableContentTypes: ContentType[];
-    readableContentTypes: ContentType[];
-    availableContentTypes: ContentType[];
-};
-export declare function useContentTypePermissions(props: ContentTypePermissionsProps): ContentTypePermissions;
-export {};
+import { ContentType, ContentEntityType, FieldExtensionSDK } from '../types';
+import { ReferenceValidations } from '../utils/fromFieldValidations';
+import { ReferenceEditorProps } from './ReferenceEditor';
+type ContentTypePermissionsProps = {
+    sdk: FieldExtensionSDK;
+    entityType: ContentEntityType;
+    parameters: ReferenceEditorProps['parameters'];
+    allContentTypes: ContentType[];
+    validations: ReferenceValidations;
+};
+type ContentTypePermissions = {
+    creatableContentTypes: ContentType[];
+    readableContentTypes: ContentType[];
+    availableContentTypes: ContentType[];
+};
+export declare function useContentTypePermissions(props: ContentTypePermissionsProps): ContentTypePermissions;
+export {};

package/dist/{common → types/common}/useEditorPermissions.d.ts

@@ -1,17 +1,17 @@
-import { ContentType, ContentEntityType, FieldExtensionSDK } from '../types';
-import { ReferenceEditorProps } from './ReferenceEditor';
-export declare type EditorPermissionsProps = {
-    sdk: FieldExtensionSDK;
-    entityType: ContentEntityType;
-    parameters: ReferenceEditorProps['parameters'];
-    allContentTypes: ContentType[];
-};
-export declare function useEditorPermissions(props: EditorPermissionsProps): {
-    canCreateEntity: boolean;
-    canLinkEntity: boolean;
-    creatableContentTypes: ContentType[];
-    readableContentTypes: ContentType[];
-    availableContentTypes: ContentType[];
-    validations: import("../utils/fromFieldValidations").ReferenceValidations;
-};
-export declare type EditorPermissions = ReturnType<typeof useEditorPermissions>;
+import { ContentType, ContentEntityType, FieldExtensionSDK } from '../types';
+import { ReferenceEditorProps } from './ReferenceEditor';
+export type EditorPermissionsProps = {
+    sdk: FieldExtensionSDK;
+    entityType: ContentEntityType;
+    parameters: ReferenceEditorProps['parameters'];
+    allContentTypes: ContentType[];
+};
+export declare function useEditorPermissions(props: EditorPermissionsProps): {
+    canCreateEntity: boolean;
+    canLinkEntity: boolean;
+    creatableContentTypes: ContentType[];
+    readableContentTypes: ContentType[];
+    availableContentTypes: ContentType[];
+    validations: import("../utils/fromFieldValidations").ReferenceValidations;
+};
+export type EditorPermissions = ReturnType<typeof useEditorPermissions>;

package/dist/types/common/useEditorPermissions.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/{components → types/components}/AssetThumbnail/AssetThumbnail.d.ts

@@ -1,7 +1,7 @@
-/// <reference types="react" />
-import { File } from '../../types';
-interface AssetThumbnailProps {
-    file: File;
-}
-export declare function AssetThumbnail(props: AssetThumbnailProps): JSX.Element;
-export {};
+import * as React from 'react';
+import { File } from '../../types';
+interface AssetThumbnailProps {
+    file: File;
+}
+export declare function AssetThumbnail(props: AssetThumbnailProps): React.JSX.Element;
+export {};

package/dist/{components → types/components}/CreateEntryLinkButton/CreateEntryLinkButton.d.ts

@@ -1,19 +1,19 @@
-import React from 'react';
-import { ContentType } from '../../types';
-interface CreateEntryLinkButtonProps {
-    contentTypes: ContentType[];
-    suggestedContentTypeId?: string;
-    onSelect: (contentTypeId: string) => Promise<unknown>;
-    customDropdownItems?: React.ReactNode;
-    disabled?: boolean;
-    hasPlusIcon?: boolean;
-    useExperimentalStyles?: boolean;
-    text?: string | React.ReactElement;
-    testId?: string;
-    dropdownSettings?: {
-        isAutoalignmentEnabled?: boolean;
-        position: 'bottom-left' | 'bottom-right';
-    };
-}
-export declare const CreateEntryLinkButton: ({ contentTypes, onSelect, customDropdownItems, text, testId, hasPlusIcon, useExperimentalStyles, suggestedContentTypeId, dropdownSettings, disabled, }: CreateEntryLinkButtonProps) => JSX.Element;
-export {};
+import * as React from 'react';
+import { ContentType } from '../../types';
+interface CreateEntryLinkButtonProps {
+    contentTypes: ContentType[];
+    suggestedContentTypeId?: string;
+    onSelect: (contentTypeId: string) => Promise<unknown>;
+    customDropdownItems?: React.ReactNode;
+    disabled?: boolean;
+    hasPlusIcon?: boolean;
+    useExperimentalStyles?: boolean;
+    text?: string | React.ReactElement;
+    testId?: string;
+    dropdownSettings?: {
+        isAutoalignmentEnabled?: boolean;
+        position: 'bottom-left' | 'bottom-right';
+    };
+}
+export declare const CreateEntryLinkButton: ({ contentTypes, onSelect, customDropdownItems, text, testId, hasPlusIcon, useExperimentalStyles, suggestedContentTypeId, dropdownSettings, disabled, }: CreateEntryLinkButtonProps) => React.JSX.Element;
+export {};

package/dist/types/components/CreateEntryLinkButton/CreateEntryLinkButton.spec.d.ts

@@ -0,0 +1 @@
+import '@testing-library/jest-dom';