@strapi/admin 4.16.1 → 4.17.0

package/dist/admin/src/pages/Settings/pages/Roles/components/ConditionsButton.d.ts

@@ -0,0 +1,12 @@
+import { ButtonProps } from '@strapi/design-system';
+interface ConditionsButtonProps extends Pick<ButtonProps, 'className' | 'onClick' | 'variant'> {
+    hasConditions?: boolean;
+}
+/**
+ * We reference the component directly in other styled-components
+ * and as such we need it to have a className already assigned.
+ * Therefore we wrapped the implementation in a styled function.
+ */
+declare const ConditionsButton: import("styled-components").StyledComponent<({ onClick, className, hasConditions, variant, }: ConditionsButtonProps) => import("react/jsx-runtime").JSX.Element, import("styled-components").DefaultTheme, {}, never>;
+export { ConditionsButton };
+export type { ConditionsButtonProps };

package/dist/admin/src/pages/Settings/pages/Roles/components/ConditionsModal.d.ts

@@ -0,0 +1,32 @@
+import { ModalLayoutProps } from '@strapi/design-system';
+import { PermissionsDataManagerContextValue } from '../hooks/usePermissionsDataManager';
+import type { HiddenCheckboxAction, VisibleCheckboxAction } from './ContentTypeCollapses';
+import type { ConditionForm } from '../utils/forms';
+interface ConditionAction extends Pick<ActionRowProps, 'label'> {
+    actionId: string;
+    isDisplayed: boolean;
+    hasSomeActionsSelected?: boolean;
+    hasAllActionsSelected?: boolean;
+    pathToConditionsObject: string[];
+}
+interface ConditionsModalProps extends Pick<ActionRowProps, 'isFormDisabled'> {
+    actions?: Array<ConditionAction | HiddenCheckboxAction | VisibleCheckboxAction>;
+    headerBreadCrumbs?: string[];
+    onClosed: ModalLayoutProps['onClose'];
+    onToggle: () => void;
+}
+declare const ConditionsModal: ({ actions, headerBreadCrumbs, isFormDisabled, onClosed, onToggle, }: ConditionsModalProps) => import("react/jsx-runtime").JSX.Element;
+interface ActionRowProps {
+    arrayOfOptionsGroupedByCategory: Array<[
+        string,
+        PermissionsDataManagerContextValue['availableConditions']
+    ]>;
+    isFormDisabled?: boolean;
+    isGrey?: boolean;
+    label: string;
+    name: string;
+    onChange?: (name: string, values: Record<string, boolean>) => void;
+    value: Record<string, ConditionForm>;
+}
+export { ConditionsModal };
+export type { ConditionsModalProps };

package/dist/admin/src/pages/Settings/pages/Roles/components/ContentTypeCollapses.d.ts

@@ -0,0 +1,35 @@
+import { Action, Subject } from '../../../../../../../shared/contracts/permissions';
+import { RowLabelWithCheckboxProps } from './RowLabelWithCheckbox';
+interface ContentTypeCollapsesProps extends Pick<CollapseProps, 'pathToData'> {
+    actions?: Action[];
+    isFormDisabled?: boolean;
+    subjects?: Subject[];
+}
+declare const ContentTypeCollapses: ({ actions, isFormDisabled, pathToData, subjects, }: ContentTypeCollapsesProps) => import("react/jsx-runtime").JSX.Element;
+interface CollapseProps extends Pick<RowLabelWithCheckboxProps, 'isActive' | 'isFormDisabled' | 'label'> {
+    availableActions?: Array<Action & {
+        isDisplayed: boolean;
+    }>;
+    isGrey?: boolean;
+    onClickToggle: RowLabelWithCheckboxProps['onClick'];
+    pathToData: string;
+}
+interface VisibleCheckboxAction {
+    actionId: string;
+    hasAllActionsSelected: boolean;
+    hasSomeActionsSelected: boolean;
+    isDisplayed: true;
+    isParentCheckbox: boolean;
+    checkboxName: string;
+    label: string;
+    hasConditions: boolean;
+    pathToConditionsObject: string[];
+}
+interface HiddenCheckboxAction {
+    actionId: string;
+    isDisplayed: false;
+    hasAllActionsSelected?: never;
+    hasSomeActionsSelected: boolean;
+}
+export { ContentTypeCollapses };
+export type { ContentTypeCollapsesProps, HiddenCheckboxAction, VisibleCheckboxAction };

package/dist/admin/src/pages/Settings/pages/Roles/components/ContentTypes.d.ts

@@ -0,0 +1,8 @@
+import { ContentPermission } from '../../../../../../../shared/contracts/permissions';
+import { GlobalActionsProps } from './GlobalActions';
+interface ContentTypesProps extends Pick<GlobalActionsProps, 'kind'> {
+    isFormDisabled?: boolean;
+    layout: ContentPermission;
+}
+declare const ContentTypes: ({ isFormDisabled, kind, layout: { actions, subjects }, }: ContentTypesProps) => import("react/jsx-runtime").JSX.Element;
+export { ContentTypes };

package/dist/admin/src/pages/Settings/pages/Roles/components/GlobalActions.d.ts

@@ -0,0 +1,10 @@
+import { Action } from '../../../../../../../shared/contracts/permissions';
+import { PermissionsDataManagerContextValue } from '../hooks/usePermissionsDataManager';
+interface GlobalActionsProps {
+    actions: Action[];
+    isFormDisabled?: boolean;
+    kind: Extract<keyof PermissionsDataManagerContextValue['modifiedData'], `${string}Types`>;
+}
+declare const GlobalActions: ({ actions, isFormDisabled, kind }: GlobalActionsProps) => import("react/jsx-runtime").JSX.Element;
+export { GlobalActions };
+export type { GlobalActionsProps };

package/dist/admin/src/pages/Settings/pages/Roles/components/HiddenAction.d.ts

@@ -0,0 +1,2 @@
+declare const HiddenAction: import("styled-components").StyledComponent<"div", import("styled-components").DefaultTheme, {}, never>;
+export { HiddenAction };

package/dist/admin/src/pages/Settings/pages/Roles/components/Permissions.d.ts

@@ -0,0 +1,54 @@
+import * as React from 'react';
+import * as PermissonContracts from '../../../../../../../shared/contracts/permissions';
+import { Permission } from '../../../../../../../shared/contracts/shared';
+import { ConditionForm, Form } from '../utils/forms';
+import { GenericLayout } from '../utils/layouts';
+export interface PermissionsAPI {
+    getPermissions: () => {
+        didUpdateConditions: boolean;
+        permissionsToSend: Omit<Permission, 'id' | 'createdAt' | 'updatedAt' | 'actionParameters'>[];
+    };
+    resetForm: () => void;
+    setFormAfterSubmit: () => void;
+}
+interface PermissionsProps {
+    isFormDisabled?: boolean;
+    permissions?: Permission[];
+    layout: PermissonContracts.GetAll.Response['data'];
+}
+declare const Permissions: React.ForwardRefExoticComponent<PermissionsProps & React.RefAttributes<PermissionsAPI>>;
+interface PermissionForms {
+    collectionTypes: Form;
+    plugins: Record<string, Form>;
+    settings: Record<string, Form>;
+    singleTypes: Form;
+}
+interface State {
+    initialData: PermissionForms;
+    modifiedData: PermissionForms;
+    layouts: {
+        collectionTypes: PermissonContracts.ContentPermission;
+        singleTypes: PermissonContracts.ContentPermission;
+        plugins: GenericLayout<PermissonContracts.PluginPermission>[];
+        settings: GenericLayout<PermissonContracts.SettingPermission>[];
+    };
+}
+interface OnChangeCollectionTypeGlobalActionCheckboxAction {
+    type: 'ON_CHANGE_COLLECTION_TYPE_GLOBAL_ACTION_CHECKBOX';
+    collectionTypeKind: keyof PermissionForms;
+    actionId: string;
+    value: boolean;
+}
+interface OnChangeCollectionTypeRowLeftCheckboxAction {
+    type: 'ON_CHANGE_COLLECTION_TYPE_ROW_LEFT_CHECKBOX';
+    pathToCollectionType: string;
+    propertyName: string;
+    rowName: string;
+    value: boolean;
+}
+interface OnChangeConditionsAction {
+    type: 'ON_CHANGE_CONDITIONS';
+    conditions: Record<string, ConditionForm>;
+}
+export { Permissions };
+export type { State, OnChangeCollectionTypeRowLeftCheckboxAction, OnChangeConditionsAction, OnChangeCollectionTypeGlobalActionCheckboxAction, };

package/dist/admin/src/pages/Settings/pages/Roles/components/PluginsAndSettings.d.ts

@@ -0,0 +1,18 @@
+import { SettingPermission, PluginPermission } from '../../../../../../../shared/contracts/permissions';
+import { PermissionsDataManagerContextValue } from '../hooks/usePermissionsDataManager';
+import type { GenericLayout } from '../utils/layouts';
+type Layout = GenericLayout<SettingPermission | PluginPermission>[];
+interface PluginsAndSettingsPermissionsProps extends Pick<RowProps, 'kind' | 'isFormDisabled'> {
+    layout: Layout;
+}
+declare const PluginsAndSettingsPermissions: ({ layout, ...restProps }: PluginsAndSettingsPermissionsProps) => import("react/jsx-runtime").JSX.Element;
+interface RowProps extends Pick<Layout[number], 'childrenForm'> {
+    kind: Exclude<keyof PermissionsDataManagerContextValue['modifiedData'], `${string}Types`>;
+    name: string;
+    isFormDisabled?: boolean;
+    isOpen?: boolean;
+    isWhite?: boolean;
+    onOpenCategory: (categoryName: string) => void;
+    pathToData: string[];
+}
+export { PluginsAndSettingsPermissions };

package/dist/admin/src/pages/Settings/pages/Roles/components/RequiredSign.d.ts

@@ -0,0 +1,2 @@
+declare const RequiredSign: () => import("react/jsx-runtime").JSX.Element;
+export { RequiredSign };

package/dist/admin/src/pages/Settings/pages/Roles/components/RoleForm.d.ts

@@ -0,0 +1,12 @@
+import { FormikProps } from 'formik';
+import type { AdminRole } from '../../../../../hooks/useAdminRoles';
+import type { EditPageFormValues } from '../EditPage';
+interface RoleFormProps extends Pick<FormikProps<EditPageFormValues>, 'values' | 'errors'> {
+    onBlur: FormikProps<EditPageFormValues>['handleBlur'];
+    onChange: FormikProps<EditPageFormValues>['handleChange'];
+    disabled?: boolean;
+    role: AdminRole;
+}
+declare const RoleForm: ({ disabled, role, values, errors, onChange, onBlur }: RoleFormProps) => import("react/jsx-runtime").JSX.Element;
+export { RoleForm };
+export type { RoleFormProps };

package/dist/admin/src/pages/Settings/pages/Roles/components/RoleRow.d.ts

@@ -0,0 +1,10 @@
+import { IconButtonProps } from '@strapi/design-system';
+import { AdminRole } from '../../../../../hooks/useAdminRoles';
+interface RoleRowProps extends Pick<AdminRole, 'id' | 'name' | 'description' | 'usersCount'> {
+    icons: Array<Required<Pick<IconButtonProps, 'icon' | 'label' | 'onClick'>>>;
+    rowIndex: number;
+    canUpdate?: boolean;
+}
+declare const RoleRow: ({ id, name, description, usersCount, icons, rowIndex, canUpdate, }: RoleRowProps) => import("react/jsx-runtime").JSX.Element;
+export { RoleRow };
+export type { RoleRowProps };

package/dist/admin/src/pages/Settings/pages/Roles/components/RowLabelWithCheckbox.d.ts

@@ -0,0 +1,17 @@
+import * as React from 'react';
+import { PermissionsDataManagerContextValue } from '../hooks/usePermissionsDataManager';
+interface RowLabelWithCheckboxProps {
+    children: React.ReactNode;
+    checkboxName?: string;
+    isActive?: boolean;
+    isCollapsable?: boolean;
+    isFormDisabled?: boolean;
+    label: string;
+    onChange: PermissionsDataManagerContextValue['onChangeParentCheckbox'];
+    onClick: () => void;
+    someChecked?: boolean;
+    value: boolean;
+}
+declare const RowLabelWithCheckbox: ({ checkboxName, children, isActive, isCollapsable, isFormDisabled, label, onChange, onClick, someChecked, value, }: RowLabelWithCheckboxProps) => import("react/jsx-runtime").JSX.Element;
+export { RowLabelWithCheckbox };
+export type { RowLabelWithCheckboxProps };

package/dist/admin/src/pages/Settings/pages/Roles/hooks/useAdminRolePermissions.d.ts

@@ -0,0 +1,13 @@
+import { Entity } from '@strapi/types';
+import { UseQueryOptions } from 'react-query';
+import { GetOwnPermissions } from '../../../../../../../shared/contracts/users';
+export interface APIRolePermissionsQueryParams {
+    id: null | Entity.ID;
+}
+export declare const useAdminRolePermissions: (params?: APIRolePermissionsQueryParams, queryOptions?: Omit<UseQueryOptions<GetOwnPermissions.Response['data']>, 'queryKey' | 'queryFn'>) => {
+    permissions: import("../../../../../../../shared/contracts/shared").Permission[] | undefined;
+    error: unknown;
+    isError: boolean;
+    isLoading: boolean;
+    refetch: <TPageData>(options?: (import("react-query").RefetchOptions & import("react-query").RefetchQueryFilters<TPageData>) | undefined) => Promise<import("react-query").QueryObserverResult<import("../../../../../../../shared/contracts/shared").Permission[], unknown>>;
+};

package/dist/admin/src/pages/Settings/pages/Roles/hooks/usePermissionsDataManager.d.ts

@@ -0,0 +1,29 @@
+/// <reference types="react" />
+import { Condition } from '../../../../../../../shared/contracts/permissions';
+import type { OnChangeCollectionTypeGlobalActionCheckboxAction, OnChangeCollectionTypeRowLeftCheckboxAction, OnChangeConditionsAction, State } from '../components/Permissions';
+export interface PermissionsDataManagerContextValue extends Pick<State, 'modifiedData'> {
+    availableConditions: Condition[];
+    onChangeCollectionTypeLeftActionRowCheckbox: (pathToCollectionType: OnChangeCollectionTypeRowLeftCheckboxAction['pathToCollectionType'], propertyName: OnChangeCollectionTypeRowLeftCheckboxAction['propertyName'], rowName: OnChangeCollectionTypeRowLeftCheckboxAction['rowName'], value: OnChangeCollectionTypeRowLeftCheckboxAction['value']) => void;
+    onChangeConditions: (conditions: OnChangeConditionsAction['conditions']) => void;
+    onChangeSimpleCheckbox: (event: {
+        target: {
+            name: string;
+            value: boolean;
+        };
+    }) => void;
+    onChangeParentCheckbox: (event: {
+        target: {
+            name: string;
+            value: boolean;
+        };
+    }) => void;
+    onChangeCollectionTypeGlobalActionCheckbox: (collectionTypeKind: OnChangeCollectionTypeGlobalActionCheckboxAction['collectionTypeKind'], actionId: OnChangeCollectionTypeGlobalActionCheckboxAction['actionId'], value: OnChangeCollectionTypeGlobalActionCheckboxAction['value']) => void;
+}
+declare const PermissionsDataManagerProvider: {
+    (props: PermissionsDataManagerContextValue & {
+        children: import("react").ReactNode;
+    }): JSX.Element;
+    displayName: string;
+};
+export declare const usePermissionsDataManager: () => PermissionsDataManagerContextValue;
+export { PermissionsDataManagerProvider };

package/dist/admin/src/pages/Settings/pages/Roles/utils/constants.d.ts

@@ -0,0 +1,3 @@
+export declare const cellWidth = "7.5rem";
+export declare const firstRowWidth = "12.5rem";
+export declare const rowHeight = "3.3125rem";

package/dist/admin/src/pages/Settings/pages/Roles/utils/createArrayOfValues.d.ts

@@ -0,0 +1,3 @@
+import { Flat } from '../../../../../utils/arrays';
+declare const createArrayOfValues: <TData>(obj: unknown) => Flat<TData>[];
+export { createArrayOfValues };

package/dist/admin/src/pages/Settings/pages/Roles/utils/forms.d.ts

@@ -0,0 +1,28 @@
+import type { GenericLayout } from './layouts';
+import type { Condition, SettingPermission, ContentPermission } from '../../../../../../../shared/contracts/permissions';
+import type { Permission } from '../../../../../../../shared/contracts/shared';
+type ConditionForm = Record<string, boolean>;
+/**
+ * Creates the default condition form: { [conditionId]: false }
+ */
+declare const createDefaultConditionsForm: (conditions: Condition[], initialConditions?: Permission['conditions']) => ConditionForm;
+interface SubCategoryForm {
+    properties: {
+        enabled: boolean;
+    };
+    conditions: ConditionForm;
+}
+type ChildrenForm = Record<string, SubCategoryForm | (Omit<SubCategoryForm, 'properties'> & PropertyForm)>;
+type Form = Record<string, ChildrenForm>;
+declare const createDefaultForm: <TLayout extends Omit<SettingPermission, "category">>(layout: GenericLayout<TLayout>[], conditions: Condition[], initialPermissions?: Permission[]) => Record<string, Form>;
+interface PropertyChildForm extends Record<string, boolean | PropertyChildForm> {
+}
+interface PropertyForm {
+    properties: PropertyChildForm;
+}
+/**
+ * Creates the default for for a content type
+ */
+declare const createDefaultCTForm: ({ subjects, actions }: ContentPermission, conditions: Condition[], initialPermissions?: Permission[]) => Form;
+export { createDefaultConditionsForm, createDefaultForm, createDefaultCTForm };
+export type { ConditionForm, Form, PropertyForm, SubCategoryForm, ChildrenForm, PropertyChildForm };

package/dist/admin/src/pages/Settings/pages/Roles/utils/getCheckboxState.d.ts

@@ -0,0 +1,8 @@
+interface RecursiveRecordOfBooleans extends Record<string, boolean | RecursiveRecordOfBooleans> {
+}
+declare const getCheckboxState: (dataObj: RecursiveRecordOfBooleans) => {
+    hasAllActionsSelected: boolean;
+    hasSomeActionsSelected: boolean;
+};
+export { getCheckboxState };
+export type { RecursiveRecordOfBooleans };

package/dist/admin/src/pages/Settings/pages/Roles/utils/layouts.d.ts

@@ -0,0 +1,13 @@
+import { SettingPermission } from '../../../../../../../shared/contracts/permissions';
+interface GenericLayout<TLayout> {
+    category: string;
+    categoryId: string;
+    childrenForm: Array<{
+        subCategoryName: string;
+        subCategoryId: string;
+        actions: TLayout[];
+    }>;
+}
+declare const formatLayout: <TLayout extends Omit<SettingPermission, "category">>(layout: TLayout[], groupByKey: keyof TLayout) => GenericLayout<TLayout>[];
+export { formatLayout };
+export type { GenericLayout };

package/dist/admin/src/pages/Settings/pages/Roles/utils/permissions.d.ts

@@ -0,0 +1,8 @@
+import type { Permission } from '../../../../../../../shared/contracts/shared';
+import type { PermissionsDataManagerContextValue } from '../hooks/usePermissionsDataManager';
+/**
+ * @description Given a users permissions array we find the first one that matches a provided subject & action
+ */
+declare const findMatchingPermission: (permissions: Permission[], action: string, subject: string | null) => Permission | undefined;
+declare const formatPermissionsForAPI: (modifiedData: PermissionsDataManagerContextValue['modifiedData']) => Omit<Permission, "id" | "createdAt" | "updatedAt" | "actionParameters">[];
+export { findMatchingPermission, formatPermissionsForAPI };

package/dist/admin/src/pages/Settings/pages/Roles/utils/removeConditionKeyFromData.d.ts

@@ -0,0 +1,8 @@
+type DataWithoutCondition<TData extends {
+    conditions?: unknown;
+}> = Omit<TData, 'conditions'>;
+declare const removeConditionKeyFromData: <TData extends {
+    conditions?: unknown;
+}>(obj?: TData | undefined) => DataWithoutCondition<TData> | null;
+export { removeConditionKeyFromData };
+export type { DataWithoutCondition };

package/dist/admin/src/pages/Settings/pages/Roles/utils/updateConditionsToFalse.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Changes all the conditions leaf when the properties are all falsy
+ */
+declare const updateConditionsToFalse: (obj: object) => object;
+export { updateConditionsToFalse };

package/dist/admin/src/pages/Settings/pages/Roles/utils/updateValues.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Sets all the none object values of an object to the given one
+ * It preserves the shape of the object, it only modifies the leafs
+ * of an object.
+ * This utility is very helpful when dealing with parent<>children checkboxes
+ */
+declare const updateValues: (obj: object, valueToSet: boolean, isFieldUpdate?: boolean) => object;
+export { updateValues };

package/dist/admin/src/pages/Settings/pages/TransferTokens/CreateView.d.ts

@@ -0,0 +1 @@
+export declare const ProtectedCreateView: () => import("react/jsx-runtime").JSX.Element;

package/dist/admin/src/pages/Settings/pages/TransferTokens/EditView.d.ts

@@ -0,0 +1,7 @@
+declare const EditView: () => import("react/jsx-runtime").JSX.Element;
+declare const ProtectedEditView: () => import("react/jsx-runtime").JSX.Element;
+interface LoadingViewProps {
+    transferTokenName?: string;
+}
+export declare const LoadingView: ({ transferTokenName }: LoadingViewProps) => import("react/jsx-runtime").JSX.Element;
+export { EditView, ProtectedEditView };

package/dist/admin/src/pages/Settings/pages/TransferTokens/ListView.d.ts

@@ -0,0 +1,3 @@
+declare const ListView: () => import("react/jsx-runtime").JSX.Element;
+declare const ProtectedListView: () => import("react/jsx-runtime").JSX.Element;
+export { ListView, ProtectedListView };

package/dist/admin/src/pages/Settings/pages/Users/EditPage.d.ts

@@ -0,0 +1,3 @@
+declare const EditPage: () => import("react/jsx-runtime").JSX.Element;
+declare const ProtectedEditPage: () => import("react/jsx-runtime").JSX.Element;
+export { EditPage, ProtectedEditPage };

package/dist/admin/src/pages/Settings/pages/Users/ListPage.d.ts

@@ -0,0 +1,22 @@
+import * as React from 'react';
+import { TableHeader } from '@strapi/helper-plugin';
+import { IntlShape, MessageDescriptor } from 'react-intl';
+import { SanitizedAdminUser } from '../../../../../../shared/contracts/shared';
+declare const ListPageCE: () => import("react/jsx-runtime").JSX.Element | null;
+interface ListPageTableHeader extends Omit<TableHeader, 'metadatas' | 'name'> {
+    name: Extract<keyof SanitizedAdminUser, 'firstname' | 'lastname' | 'email' | 'roles' | 'username' | 'isActive'>;
+    cellFormatter?: (data: SanitizedAdminUser, meta: Omit<ListPageTableHeaderWithStringMetadataLabel, 'cellFormatter'> & Pick<IntlShape, 'formatMessage'>) => React.ReactNode;
+    key: string;
+    metadatas: {
+        label: MessageDescriptor;
+    } & Omit<TableHeader['metadatas'], 'label'>;
+}
+interface ListPageTableHeaderWithStringMetadataLabel extends Omit<ListPageTableHeader, 'metadatas'> {
+    metadatas: {
+        label: string;
+    } & Omit<ListPageTableHeader['metadatas'], 'label'>;
+}
+declare const ListPage: () => import("react/jsx-runtime").JSX.Element | null;
+declare const ProtectedListPage: () => import("react/jsx-runtime").JSX.Element;
+export { ProtectedListPage, ListPage, ListPageCE };
+export type { ListPageTableHeaderWithStringMetadataLabel as ListPageTableHeader };

package/dist/admin/src/pages/Settings/pages/Users/components/CreateActionCE.d.ts

@@ -0,0 +1,6 @@
+import { ButtonProps } from '@strapi/design-system';
+interface CreateActionCEProps extends Pick<ButtonProps, 'onClick'> {
+}
+declare const CreateActionCE: ({ onClick }: CreateActionCEProps) => import("react/jsx-runtime").JSX.Element;
+export { CreateActionCE };
+export type { CreateActionCEProps };

package/dist/admin/src/pages/Settings/pages/Users/components/MagicLinkCE.d.ts

@@ -0,0 +1,6 @@
+interface MagicLinkCEProps {
+    registrationToken: string;
+}
+declare const MagicLinkCE: ({ registrationToken }: MagicLinkCEProps) => import("react/jsx-runtime").JSX.Element;
+export { MagicLinkCE };
+export type { MagicLinkCEProps };

package/dist/admin/src/pages/Settings/pages/Users/components/MagicLinkWrapper.d.ts

@@ -0,0 +1,7 @@
+interface MagicLinkWrapperProps {
+    children: string;
+    target: string;
+}
+declare const MagicLinkWrapper: ({ children, target }: MagicLinkWrapperProps) => import("react/jsx-runtime").JSX.Element;
+export { MagicLinkWrapper };
+export type { MagicLinkWrapperProps };

package/dist/admin/src/pages/Settings/pages/Users/components/NewUserForm.d.ts

@@ -0,0 +1,15 @@
+import { Entity } from '@strapi/types';
+interface ModalFormProps {
+    onSuccess: () => Promise<void>;
+    onToggle: () => void;
+}
+declare const ModalForm: ({ onSuccess, onToggle }: ModalFormProps) => import("react/jsx-runtime").JSX.Element | null;
+interface InitialData {
+    firstname?: string;
+    lastname?: string;
+    email?: string;
+    roles?: Entity.ID[];
+    useSSORegistration?: boolean;
+}
+export { ModalForm };
+export type { InitialData };

package/dist/admin/src/pages/Settings/pages/Users/components/SelectRoles.d.ts

@@ -0,0 +1,8 @@
+import { FieldInputProps } from 'formik';
+import type { Entity } from '@strapi/types';
+interface SelectRolesProps extends Pick<FieldInputProps<Entity.ID[]>, 'onChange' | 'value'> {
+    disabled?: boolean;
+    error?: string;
+}
+declare const SelectRoles: ({ disabled, error, onChange, value }: SelectRolesProps) => import("react/jsx-runtime").JSX.Element;
+export { SelectRoles };

package/dist/admin/src/pages/Settings/pages/Users/components/TableRows.d.ts

@@ -0,0 +1,9 @@
+import { TableRowProps } from '@strapi/helper-plugin';
+import { SanitizedAdminUser } from '../../../../../../../shared/contracts/shared';
+import type { ListPageTableHeader } from '../ListPage';
+interface TableRowsProps extends Partial<TableRowProps<SanitizedAdminUser, ListPageTableHeader>> {
+    canDelete: boolean;
+}
+declare const TableRows: ({ canDelete, headers, entriesToDelete, onClickDelete, onSelectRow, withMainAction, withBulkActions, rows, }: TableRowsProps) => import("react/jsx-runtime").JSX.Element;
+export { TableRows };
+export type { TableRowsProps };

package/dist/admin/src/pages/Settings/pages/Users/utils/validation.d.ts

@@ -0,0 +1,13 @@
+import * as yup from 'yup';
+/**
+ * @description This needs wrapping in `yup.object().shape()` before use.
+ */
+declare const COMMON_USER_SCHEMA: {
+    firstname: import("yup/lib/string").RequiredStringSchema<string | undefined, Record<string, any>>;
+    lastname: yup.default<string | undefined, Record<string, any>, string | undefined>;
+    email: import("yup/lib/string").RequiredStringSchema<string | undefined, Record<string, any>>;
+    username: yup.default<string | null | undefined, Record<string, any>, string | null | undefined>;
+    password: yup.default<string | undefined, Record<string, any>, string | undefined>;
+    confirmPassword: yup.default<string | undefined, Record<string, any>, string | undefined>;
+};
+export { COMMON_USER_SCHEMA };

package/dist/admin/src/pages/Settings/pages/Webhooks/CreatePage.d.ts

@@ -0,0 +1,3 @@
+import { EditPage } from './EditPage';
+declare const ProtectedCreatePage: () => import("react/jsx-runtime").JSX.Element;
+export { ProtectedCreatePage, EditPage as CreatePage };

package/dist/admin/src/pages/Settings/pages/Webhooks/EditPage.d.ts

@@ -0,0 +1,3 @@
+declare const EditPage: () => import("react/jsx-runtime").JSX.Element;
+declare const ProtectedEditPage: () => import("react/jsx-runtime").JSX.Element;
+export { ProtectedEditPage, EditPage };

package/dist/admin/src/pages/Settings/pages/Webhooks/ListPage.d.ts

@@ -0,0 +1,3 @@
+declare const ListPage: () => import("react/jsx-runtime").JSX.Element;
+declare const ProtectedListPage: () => import("react/jsx-runtime").JSX.Element;
+export { ListPage, ProtectedListPage };

package/dist/admin/src/pages/Settings/pages/Webhooks/components/Events.d.ts

@@ -0,0 +1,32 @@
+import * as React from 'react';
+import { FieldInputProps } from 'formik';
+import { MessageDescriptor } from 'react-intl';
+interface EventsRootProps {
+    children: React.ReactNode;
+}
+interface EventsHeadersProps {
+    getHeaders?: typeof getCEHeaders;
+}
+declare const getCEHeaders: (isDraftAndPublish: boolean) => MessageDescriptor[];
+interface FormikContextValue {
+    events: string[];
+}
+interface EventsBodyProps {
+    providedEvents?: Record<string, FormikContextValue['events']>;
+}
+interface EventsRowProps {
+    disabledEvents?: string[];
+    events?: string[];
+    inputValue?: string[];
+    handleSelect: FieldInputProps<string>['onChange'];
+    handleSelectAll: FieldInputProps<string>['onChange'];
+    name: string;
+}
+declare const Events: {
+    Root: ({ children }: EventsRootProps) => import("react/jsx-runtime").JSX.Element;
+    Headers: ({ getHeaders }: EventsHeadersProps) => import("react/jsx-runtime").JSX.Element;
+    Body: ({ providedEvents }: EventsBodyProps) => import("react/jsx-runtime").JSX.Element;
+    Row: ({ disabledEvents, name, events, inputValue, handleSelect, handleSelectAll, }: EventsRowProps) => import("react/jsx-runtime").JSX.Element;
+};
+export { Events };
+export type { EventsRowProps, EventsHeadersProps, EventsRootProps, EventsBodyProps };

package/dist/admin/src/pages/Settings/pages/Webhooks/components/EventsTable.d.ts

@@ -0,0 +1,2 @@
+declare const EventTableCE: () => import("react/jsx-runtime").JSX.Element;
+export { EventTableCE };

package/dist/admin/src/pages/Settings/pages/Webhooks/components/HeadersInput.d.ts

@@ -0,0 +1,2 @@
+declare const HeadersInput: () => import("react/jsx-runtime").JSX.Element;
+export { HeadersInput };

package/dist/admin/src/pages/Settings/pages/Webhooks/components/TriggerContainer.d.ts

@@ -0,0 +1,13 @@
+interface TriggerContainerProps extends Pick<StatusProps, 'isPending'> {
+    onCancel: () => void;
+    response?: {
+        statusCode: number;
+        message?: string;
+    };
+}
+declare const TriggerContainer: ({ isPending, onCancel, response }: TriggerContainerProps) => import("react/jsx-runtime").JSX.Element;
+interface StatusProps {
+    isPending: boolean;
+    statusCode?: number;
+}
+export { TriggerContainer };

package/dist/admin/src/pages/Settings/pages/Webhooks/components/WebhookForm.d.ts

@@ -0,0 +1,22 @@
+import { Webhook } from '@strapi/types';
+import { TriggerWebhook } from '../../../../../../../shared/contracts/webhooks';
+interface WebhookFormValues {
+    name: Webhook['name'];
+    url: Webhook['url'];
+    headers: Array<{
+        key: string;
+        value: string;
+    }>;
+    events: Webhook['events'];
+}
+interface WebhookFormProps {
+    data?: Webhook;
+    handleSubmit: (values: WebhookFormValues) => void;
+    isCreating: boolean;
+    isTriggering: boolean;
+    triggerWebhook: () => void;
+    triggerResponse?: TriggerWebhook.Response['data'];
+}
+declare const WebhookForm: ({ handleSubmit, triggerWebhook, isCreating, isTriggering, triggerResponse, data, }: WebhookFormProps) => import("react/jsx-runtime").JSX.Element | null;
+export { WebhookForm };
+export type { WebhookFormValues, WebhookFormProps };

package/dist/admin/src/pages/Settings/utils/forms.d.ts

@@ -0,0 +1,3 @@
+import { MessageDescriptor } from 'react-intl';
+declare const isErrorMessageMessageDescriptor: (message: string | MessageDescriptor) => message is MessageDescriptor;
+export { isErrorMessageMessageDescriptor };