@aws-amplify/ui-react-storage 3.9.1 → 3.9.2

package/dist/types/components/StorageBrowser/storage-internal.d.ts

@@ -1 +1 @@
-export { AWSTemporaryCredentials, CopyInput, CredentialsLocation, CredentialsProvider, GetUrlInput, ListLocations, ListLocationsOutput, ListOutput, ListPaginateInput, LocationAccess, LocationCredentials, LocationCredentialsProvider, Permission, RemoveInput, StorageAccess, StorageSubpathStrategy, StorageValidationErrorCode, UploadDataInput, ListPathsOutput, assertValidationError, copy, getDataAccess, getUrl, list, listCallerAccessGrants, listPaths, remove, uploadData, validationErrorMap, } from '@aws-amplify/storage/internals';
+export { AWSTemporaryCredentials, CopyInput, CopyOutput, CredentialsLocation, CredentialsProvider, GetUrlInput, ListLocations, ListLocationsOutput, ListOutput, ListPaginateInput, LocationAccess, LocationCredentials, LocationCredentialsProvider, Permission, RemoveInput, StorageAccess, StorageSubpathStrategy, StorageValidationErrorCode, UploadDataInput, ListPathsOutput, assertValidationError, copy, getDataAccess, getUrl, list, listCallerAccessGrants, listPaths, remove, uploadData, validationErrorMap, } from '@aws-amplify/storage/internals';

package/dist/types/components/StorageBrowser/tasks/index.d.ts

@@ -1,3 +1,3 @@
 export { INITIAL_STATUS_COUNTS } from './constants';
 export { useProcessTasks } from './useProcessTasks';
-export { StatusCounts, Task, Tasks, TaskStatus } from './types';
+export { ProcessTasksOptions, StatusCounts, Task, TaskStatus, TasksState, } from './types';

package/dist/types/components/StorageBrowser/tasks/types.d.ts

@@ -1,33 +1,51 @@
-import { TaskHandlerInput, TaskData } from '../actions';
-export type TaskStatus = 'CANCELED' | 'FAILED' | 'COMPLETE' | 'OVERWRITE_PREVENTED' | 'QUEUED' | 'PENDING';
+import { TaskHandlerInput, TaskData, TaskResult, TaskResultStatus } from '../actions';
+/**
+ * extends {@link TaskResultStatus} to include `QUEUED` and `PENDING` statuses
+ * used in task processing
+ */
+export type TaskStatus = TaskResultStatus | 'QUEUED' | 'PENDING';
+/**
+ * aggregate task status counts
+ */
 export type StatusCounts = Record<TaskStatus | 'TOTAL', number>;
-export interface ProcessTasksOptions<T extends TaskData = TaskData, V = any, U extends number | never = never> {
-    concurrency?: U;
-    onTaskCancel?: (data: Task<T>) => void;
-    onTaskComplete?: (data: Task<T>) => void;
-    onTaskError?: (data: Task<T>, error: Error | undefined) => void;
-    onTaskProgress?: (data: Task<T>, progress: number | undefined) => void;
-    onTaskSuccess?: (data: Task<T>, value: V | undefined) => void;
-    onTaskRemove?: (data: Task<T>) => void;
+export interface ProcessTasksOptions<TTask extends Task, TItems = []> {
+    concurrency?: number;
+    items?: TItems;
+    onTaskCancel?: (task: TTask) => void;
+    onTaskComplete?: (task: TTask) => void;
+    onTaskError?: (task: TTask, error: unknown) => void;
+    onTaskProgress?: (task: TTask, progress: number | undefined) => void;
+    onTaskSuccess?: (task: TTask, value: TTask['value'] | undefined) => void;
+    onTaskRemove?: (task: TTask) => void;
 }
-export interface Task<T extends TaskData = TaskData, V = any> {
-    data: T;
-    message: string | undefined;
-    progress: number | undefined;
-    status: TaskStatus;
+/**
+ * `task` properties, extends {@link TaskResult} with task data, optional cancel
+ * handler and progress
+ */
+export interface Task<TData = unknown, TValue = any> extends TaskResult<TaskStatus, TValue> {
+    /**
+     * task specific data
+     */
+    data: TData & TaskData;
+    /**
+     * task progress
+     */
+    progress?: number;
+    /**
+     * cancel handler
+     */
     cancel?: () => void;
-    value?: V;
 }
-export type Tasks<T extends TaskData, V = any> = Task<T, V>[];
-export type HandleProcessTasks<T extends TaskData, U> = (input: U extends T[] ? Omit<TaskHandlerInput<T>, 'data'> : TaskHandlerInput<T>) => void;
-export interface TasksState<T extends TaskData = TaskData> {
+export type HandleProcessTasks<TInput> = (input: TInput) => void;
+export interface TasksState<TTask> {
     isProcessing: boolean;
     isProcessingComplete: boolean;
     reset: () => void;
     statusCounts: StatusCounts;
-    tasks: Tasks<T>;
+    tasks: TTask[];
 }
-export type UseProcessTasksState<T extends TaskData, D> = [
-    TasksState<T>,
-    HandleProcessTasks<T, D>
+export type UseProcessTasksState<TTask, TInput> = [
+    TasksState<TTask>,
+    HandleProcessTasks<TInput>
 ];
+export type InferHandleTasksInput<TItems, TData extends TaskData> = TItems extends NonNullable<TItems> ? Omit<TaskHandlerInput<TData>, 'data'> : TaskHandlerInput<TData>;

package/dist/types/components/StorageBrowser/tasks/useProcessTasks.d.ts

@@ -1,3 +1,3 @@
-import { ActionHandler, TaskData } from '../actions';
-import { ProcessTasksOptions, UseProcessTasksState } from './types';
-export declare const useProcessTasks: <TData extends TaskData = TaskData, RValue = any, D extends TData[] | undefined = undefined>(handler: ActionHandler<TData, RValue>, items?: D | undefined, options?: ProcessTasksOptions<TData, RValue, D extends TData[] ? number : never> | undefined) => UseProcessTasksState<TData, D>;
+import { ActionHandler } from '../actions';
+import { InferHandleTasksInput, Task, ProcessTasksOptions, UseProcessTasksState } from './types';
+export declare function useProcessTasks<TData, TValue, TTask extends Task<TData, TValue>, TInput extends InferHandleTasksInput<TItems, TTask['data']>, TItems extends TTask['data'][] | undefined = undefined>(handler: ActionHandler<TData, TValue>, options?: ProcessTasksOptions<TTask, TItems>): UseProcessTasksState<TTask, TInput>;

package/dist/types/components/StorageBrowser/types.d.ts

@@ -1,57 +1,213 @@
 import React from 'react';
-import { CustomActionConfigs, DefaultActionConfigs, ExtendedActionConfigs, ListLocations } from './actions';
+import { CustomActionConfigs, DefaultActionConfigs, ExtendedActionConfigs, ListLocations, LocationData } from './actions';
 import { GetLocationCredentials } from './credentials/types';
-import { Components } from './ComponentsProvider';
 import { ErrorBoundaryType } from './ErrorBoundary';
+import { StorageBrowserComponents } from './ComponentsProvider';
 import { RegisterAuthListener, StoreProviderProps } from './providers';
-import { CopyViewType, CreateFolderViewType, DeleteViewType, UploadViewType, LocationActionViewType, LocationDetailViewType, LocationsViewType, Views, UseView } from './views';
+import { CopyViewType, CreateFolderViewType, DeleteViewType, UploadViewType, LocationActionViewType, LocationDetailViewType, LocationsViewType, UseView, StorageBrowserViews } from './views';
 import { StorageBrowserDisplayText } from './displayText';
 import { DerivedActionHandlers, UseAction } from './useAction';
-export interface Config {
+/**
+ * Configuration properties
+ */
+export interface StorageBrowserConfig {
+    /**
+     * AWS account Id
+     */
     accountId?: string;
+    /**
+     * Custom S3 endpoint used in action handler calls
+     */
     customEndpoint?: string;
+    /**
+     * Location credentials retrieval handler
+     */
     getLocationCredentials: GetLocationCredentials;
+    /**
+     * @required
+     *
+     * Locations list handler
+     */
     listLocations: ListLocations;
+    /**
+     * @required
+     *
+     * Provided handler receives an `onStateChange` callback to be called from
+     * the consumer on auth status changes to clear in-memory credentials
+     *
+     * @example
+     * ```tsx
+     * // src/auth.ts
+     * class MyAuth {
+     *   // ...other private fields
+     *   private onStateChange: () => void | undefined;
+     *
+     *   registerAuthListener = (onStateChange: () => void) => {
+     *     // set `onStateChange` callback
+     *     this.onStateChange = onStateChange;
+     *   };
+     *
+     *   signOut() {
+     *     // ...do sign out stuff
+     *
+     *     // run `onStateChange` callback
+     *     this.onStateChange?.();
+     *   }
+     * }
+     *
+     * export const myAuth = new MyAuth();
+     *
+     * // src/storage-browser.ts
+     * import {
+     *   createStorageBrowser,
+     *   createManagedAuthAdapter
+     * } from '@aws-amplify/ui-react-storage/browser';
+     *
+     * import { myAuth } from './auth.ts';
+     *
+     * const managedAuthAdapter = createManagedAuthAdapter({
+     *   accountId: myAuth.accountId,
+     *   credentialsProvider: myAuth.credentialsProvider,
+     *   region: myAuth.region,
+     *   registerAuthListener: myAuth.registerAuthListener,
+     * });
+     *
+     * export const { StorageBrowser } = createStorageBrowser({
+     *   config: managedAuthAdapter,
+     * });
+     * ```
+     */
     registerAuthListener: RegisterAuthListener;
+    /**
+     * @required
+     *
+     * AWS account region
+     */
     region: string;
 }
 export interface StorageBrowserActions {
     default?: DefaultActionConfigs;
     custom?: CustomActionConfigs;
 }
+/**
+ * Configuration and options for `createStorageBrowser`
+ */
 export interface CreateStorageBrowserInput {
+    /**
+     * Override and default `StorageBrowser` actions and action view configs
+     */
     actions?: StorageBrowserActions;
-    config: Config;
-    components?: Components;
+    /**
+     * `StorageBrowser` configuration properties
+     */
+    config: StorageBrowserConfig;
     /**
      * Custom ErrorBoundary class. If omitted, a default ErrorBoundary is provided.
      * To disable ErrorBoundary, set to `null`.
      */
     ErrorBoundary?: ErrorBoundaryType | null;
+    /**
+     * Overrides default `components` used within `StorageBrowser`
+     */
+    components?: StorageBrowserComponents;
 }
+/**
+ * `StorageBrowser` component properties
+ */
 export interface StorageBrowserProps<K = string, V = {}> {
+    /**
+     * Overrides default display string values. Supports resolving of static and dynamic text
+     * values and error messages
+     *
+     * @example
+     * ```tsx
+     * const myDisplayText = {
+     *   CreateFolderView: {
+     *     // static text
+     *     // default: "Create folder"
+     *     title: 'Add subfolder",
+     *
+     *     // dynamic text
+     *     // default: () => 'Folder name cannot contain "/", nor start or end with "."'
+     *     getValidationMessage?: (folderName) =>
+     *       `Folder name "${folderName}" cannot contain "/", nor start or end with "."`
+     *   }
+     * }
+     *
+     * <StorageBrowser displayText={{ displayText: myDisplayText }} />
+     * ```
+     */
     displayText?: StorageBrowserDisplayText;
-    views?: Views<K, V>;
+    /**
+     * Accepts default top level `views` overrides and custom `views` defined by the `actions`
+     * parameter of `createStorageBrowser`
+     */
+    views?: StorageBrowserViews<K, V>;
 }
-export interface StorageBrowserProviderProps<V = {}> extends StoreProviderProps {
-    displayText?: StorageBrowserDisplayText;
+/**
+ * `StorageBrowser.Provider` component properties
+ */
+export interface StorageBrowserProviderProps<V = {}> extends StoreProviderProps, Pick<StorageBrowserProps, 'displayText'> {
+    /**
+     * Accepts custom action views rendered by `LocationActionView`
+     */
     views?: V;
+    /**
+     * Sets initial `location` data. Provide to initialize the `StorageBrowser` with an initial
+     * `location`
+     */
+    location?: LocationData;
 }
+/**
+ * `StorageBrowser` component, provider and view components
+ */
 export interface StorageBrowserType<K = string, V = {}> {
     (props: StorageBrowserProps<K, V>): React.JSX.Element;
     displayName: string;
+    /**
+     * `StorageBrowser` React.Context provider. Composed `StorageBrowser` components
+     * must be a descendant of a `Provider` element
+     *
+     * @example
+     * ```tsx
+     * <StorageBrowser.Provider>
+     *   <Modal content={<StorageBrowser.UploadView />}>
+     * </StorageBrowser.Provider>
+     * ```
+     */
     Provider: (props: StorageBrowserProviderProps<V>) => React.JSX.Element;
+    /**
+     * Utility view aggregating all action views. Can be used to render a standalone
+     * action view
+     *
+     * @example
+     * ```tsx
+     * <StorageBrowser.LocationActionView type="copy" />
+     * ```
+     */
+    LocationActionView: LocationActionViewType<K>;
+    /**
+     * Displays data related to the selected or provided `location` and action
+     * selection
+     */
+    LocationDetailView: LocationDetailViewType;
+    /**
+     * Entry point view displaying `locations` returned from `listLocations`
+     */
+    LocationsView: LocationsViewType;
+    /**
+     * Standalone composable default action view components
+     */
     CopyView: CopyViewType;
     CreateFolderView: CreateFolderViewType;
     DeleteView: DeleteViewType;
     UploadView: UploadViewType;
-    LocationActionView: LocationActionViewType<K>;
-    LocationDetailView: LocationDetailViewType;
-    LocationsView: LocationsViewType;
 }
 type DefaultActionType<T = string> = Exclude<T, keyof DefaultActionConfigs>;
 /**
- * @internal @unstable
+ * @internal @unstable interface subject to change, not recommended for public use
+ *
+ * Utility type resolving available custom action view component slots
  */
 export type DerivedActionViews<T extends StorageBrowserActions> = {
     [K in keyof T['custom'] as K extends DefaultActionType<K> ? T['custom'][K] extends {
@@ -59,16 +215,36 @@ export type DerivedActionViews<T extends StorageBrowserActions> = {
     } ? T['custom'][K]['viewName'] : never : never]?: () => React.JSX.Element | null;
 };
 /**
- * @internal @unstable
+ * @internal @unstable interface subject to change, not recommended for public use
+ *
+ * Utility type of excluded action keys that do not have a corresponding action view
+ */
+type DefaultActionWithoutViewType = 'download';
+/**
+ * @internal @unstable interface subject to change, not recommended for public use
+ *
+ * Utility type resolving available location action view types
  */
 export type DerivedActionViewType<T extends StorageBrowserActions> = keyof {
     [K in keyof T['custom'] as K extends DefaultActionType<K> ? T['custom'][K] extends {
         viewName: `${string}View`;
     } ? K : never : never]?: any;
-} | Exclude<keyof DefaultActionConfigs, 'download'>;
+} | Exclude<keyof DefaultActionConfigs, DefaultActionWithoutViewType>;
+/**
+ * Return values of `createStorageBrowser`
+ */
 export interface CreateStorageBrowserOutput<C extends ExtendedActionConfigs = ExtendedActionConfigs> {
+    /**
+     * `StorageBrowser` component and subcomponents
+     */
     StorageBrowser: StorageBrowserType<DerivedActionViewType<C>, DerivedActionViews<C>>;
+    /**
+     * Action handler utility hook
+     */
     useAction: UseAction<DerivedActionHandlers<C>>;
+    /**
+     * View state utility hook
+     */
     useView: UseView;
 }
 export {};

package/dist/types/components/StorageBrowser/useAction/types.d.ts

@@ -1,7 +1,7 @@
 import React from 'react';
 import { DataState } from '@aws-amplify/ui-react-core';
-import { ActionHandler, ExtendedActionConfigs, CopyHandler, CreateFolderHandler, DeleteHandler, DownloadHandler, ListLocationItemsHandler, ListLocations, LocationData, TaskData, UploadHandler } from '../actions';
-import { StatusCounts, Task, Tasks } from '../tasks';
+import { ActionHandler, ExtendedActionConfigs, CopyHandler, CreateFolderHandler, DeleteHandler, DownloadHandler, ListLocationItemsHandler, ListLocations, LocationData, UploadHandler } from '../actions';
+import { ProcessTasksOptions, StatusCounts, Task } from '../tasks';
 export type ListActionState<T = any, K = any> = [
     state: DataState<T>,
     handleAction: (...input: K[]) => void
@@ -29,48 +29,76 @@ export type ResolveHandlerType<T> = T extends {
 export type DerivedActionHandlers<C extends ExtendedActionConfigs = ExtendedActionConfigs, D extends DerivedCustomActions<C> = DerivedCustomActions<C>> = DefaultActionHandlers & {
     [K in keyof D]: ResolveHandlerType<D[K]>;
 };
-export interface HandleTasksOptions<U extends TaskData = TaskData> {
-    items: U[];
-    onTaskSuccess?: (task: Task<U>) => void;
+export type InferTask<THandler> = THandler extends ActionHandler<infer TData, infer TValue> ? Task<TData, TValue> : never;
+export interface UseHandlerOptions<TTask extends Task> extends Pick<ProcessTasksOptions<TTask>, 'onTaskError' | 'onTaskProgress' | 'onTaskSuccess'> {
 }
-interface HandleTasksInput {
-    location?: LocationData;
+export interface UseHandlerOptionsWithItems<TTask extends Task> extends UseHandlerOptions<TTask> {
+    items: TTask['data'][];
 }
-export interface HandleTaskInput<T, K> {
-    data: T;
+export interface HandleTasksInput {
     location?: LocationData;
-    options?: {
-        onSuccess?: (data: {
-            id: string;
-            key: string;
-        }, value: K) => void;
-        onError?: (data: {
-            id: string;
-            key: string;
-        }, message: string | undefined) => void;
-    };
 }
-export type HandlerInput<T extends TaskData, K, U = undefined> = U extends undefined ? HandleTaskInput<T, K> : HandleTasksInput;
-export interface TasksState<T extends TaskData, V = any> {
+export interface TasksState<TTask> {
     isProcessing: boolean;
     isProcessingComplete: boolean;
     reset: () => void;
     statusCounts: StatusCounts;
-    tasks: Tasks<T, V>;
+    tasks: TTask[];
 }
-export type HandleTasks = (input?: HandleTasksInput) => void;
-export type UseTasksState<T extends TaskData, V = any> = [
-    TasksState<T, V>,
-    HandleTasks
+export type HandleTasksState<TTask> = [
+    TasksState<TTask>,
+    (input?: HandleTasksInput) => void
 ];
-export type HandleTask<T, K> = (input: HandleTaskInput<T, K>) => void;
-export type UseTaskState<T extends TaskData, R> = [
+export type HandleTaskState<TTask extends Task> = [
     {
-        task: Task<T, R> | undefined;
+        task: TTask;
         isProcessing: boolean;
     },
-    HandleTask<T, R>
+    (input: HandleTaskInput<TTask['data']>) => void
+];
+export interface HandleTaskInput<TData> {
+    data: TData;
+    location?: LocationData;
+}
+export interface UseActionOptions<TTask extends Task> extends UseHandlerOptions<TTask> {
+}
+export interface UseActionOptionsWithItems<TTask extends Task> extends UseActionOptions<TTask> {
+    items: TTask['data'][];
+}
+interface HandleActionsInput extends HandleTasksInput {
+}
+export type UseActionsState<TTask> = [
+    TasksState<TTask>,
+    (input?: HandleActionsInput) => void
 ];
-export type UseHandlerState<T extends TaskData, R, U = undefined> = U extends undefined ? UseTaskState<T, R> : UseTasksState<T, R>;
-export type UseAction<V extends Record<keyof V, ActionHandler>> = <K extends keyof V, TData extends V[K] extends ActionHandler<infer D> ? D & TaskData : never, TOptions extends HandleTasksOptions<TData>, U extends TOptions | undefined = undefined>(key: K, options?: U) => UseHandlerState<TData, V[K] extends ActionHandler<any, infer R> ? R : never, U>;
+interface HandleActionInput<TTask> extends HandleTaskInput<TTask> {
+}
+export type UseActionState<TTask extends Task> = [
+    {
+        task: TTask | undefined;
+        isProcessing: boolean;
+    },
+    (input: HandleActionInput<TTask['data']>) => void
+];
+/**
+ * `StorageBrowser` utility hook used to run default and custom action handlers
+ * from within a parent `StorageBrowser.Provider`. `useAction` provides the
+ * action handler with the current `location` state and credentials values,
+ * as well as any parameters provided as `data` at the `useAction` call site
+ */
+export interface UseAction<Handlers extends Record<keyof Handlers, ActionHandler>> {
+    /**
+     * accepts `handler` to be run as initial argument and `options` with `items`
+     * as second. Returns batch task state and `handler` accoeting optional input
+     * allowing for location override
+     */
+    <K extends keyof Handlers, TTask extends InferTask<Handlers[K]>>(key: K, options: UseActionOptionsWithItems<TTask>): UseActionsState<TTask>;
+    /**
+     * * accepts `handler` to be run as initial argument and `options` as second.
+     * Returns atomic task `state` and `handler``input`, `handler`  requires `input`
+     * containing `data` and `options`
+     */
+    <K extends keyof Handlers, TTask extends InferTask<Handlers[K]>>(key: K, options?: UseActionOptions<TTask>): UseActionState<TTask>;
+    <K extends keyof Handlers, TTask extends InferTask<Handlers[K]>>(key: K, options?: UseActionOptionsWithItems<TTask> | UseActionOptions<TTask>): UseActionsState<TTask> | UseActionState<TTask>;
+}
 export {};

package/dist/types/components/StorageBrowser/useAction/useHandler.d.ts

@@ -1,3 +1,4 @@
-import { TaskData, TaskHandler, TaskHandlerInput, TaskHandlerOutput } from '../actions';
-import { HandleTasksOptions, UseHandlerState } from './types';
-export declare const useHandler: <TData extends TaskData, RValue, TOptions extends HandleTasksOptions<TData>, U extends TOptions | undefined = undefined>(action: TaskHandler<TaskHandlerInput<TData, import("../actions").TaskHandlerOptions<any>>, TaskHandlerOutput<RValue>>, options?: U | undefined) => UseHandlerState<TData, RValue, U>;
+import { ActionHandler } from '../actions';
+import { InferTask, HandleTaskState, HandleTasksState, UseHandlerOptions, UseHandlerOptionsWithItems } from './types';
+export declare function useHandler<THandler extends ActionHandler, TTask extends InferTask<THandler>>(handler: THandler, options: UseHandlerOptionsWithItems<TTask>): HandleTasksState<TTask>;
+export declare function useHandler<THandler extends ActionHandler, TTask extends InferTask<THandler>>(handler: THandler, options?: UseHandlerOptions<TTask>): HandleTaskState<TTask>;

package/dist/types/components/StorageBrowser/useAction/useList.d.ts

@@ -1,9 +1,12 @@
-declare const LIST_ACTION_HOOKS: {
-    folderItems: () => import("./useListFolderItems").UseListFolderItemsState;
-    locationItems: () => import("./useListLocationItems").UseListLocationItemsState;
-    locations: () => import("./useListLocations").UseListLocationsState;
-};
-type ListActionHooks = typeof LIST_ACTION_HOOKS;
-export type UseList = <K extends keyof ListActionHooks, S extends ListActionHooks[K]>(type: K) => ReturnType<S>;
+import { UseListLocationsState } from './useListLocations';
+import { UseListLocationItemsState } from './useListLocationItems';
+import { UseListFolderItemsState } from './useListFolderItems';
+interface DefaultUseListStates {
+    folderItems: UseListFolderItemsState;
+    locationItems: UseListLocationItemsState;
+    locations: UseListLocationsState;
+}
+type UseListType = keyof DefaultUseListStates;
+export type UseList = <K extends UseListType>(type: K) => DefaultUseListStates[K];
 export declare const useList: UseList;
 export {};

package/dist/types/components/StorageBrowser/views/LocationActionView/CopyView/types.d.ts

@@ -47,3 +47,8 @@ export interface FoldersState {
     onSearchClear: () => void;
     onSelectFolder: (id: string, folderLocationPath: string) => void;
 }
+export interface CopyViewState extends ActionViewState<CopyHandlerData> {
+    folders: FoldersState;
+    destination: LocationState;
+    onSelectDestination: (location: LocationData, path?: string) => void;
+}

package/dist/types/components/StorageBrowser/views/LocationActionView/UploadView/types.d.ts

@@ -1,7 +1,7 @@
 import { LocationData, UploadHandlerData } from '../../../actions';
-import { FileItem, FileItems } from '../../../providers';
+import { FileItems } from '../../../providers';
 import { ActionViewType, ActionViewProps, ActionViewState } from '../types';
-export interface UploadViewState extends ActionViewState<FileItem> {
+export interface UploadViewState extends ActionViewState<UploadHandlerData> {
     isOverwritingEnabled: boolean;
     onDropFiles: (files: File[]) => void;
     onSelectFiles: (type: 'FILE' | 'FOLDER') => void;

package/dist/types/components/StorageBrowser/views/LocationActionView/types.d.ts

@@ -1,8 +1,8 @@
 import { LocationData, TaskData } from '../../actions';
-import { LocationState } from '../../providers/store/location';
-import { StatusCounts, Task, Tasks } from '../../tasks';
-import { DataTableProps } from '../../composables/DataTable';
 import { WithKey } from '../../components/types';
+import { DataTableProps } from '../../composables/DataTable';
+import { LocationState } from '../../providers/store/location';
+import { StatusCounts, Task } from '../../tasks';
 export interface ActionViewState<T extends TaskData = TaskData> {
     isProcessing: boolean;
     isProcessingComplete: boolean;
@@ -12,7 +12,7 @@ export interface ActionViewState<T extends TaskData = TaskData> {
     onActionStart: () => void;
     onTaskRemove?: (task: Task<T>) => void;
     statusCounts: StatusCounts;
-    tasks: Tasks<T>;
+    tasks: Task<T>[];
 }
 export interface ActionViewProps {
     children?: React.ReactNode;

package/dist/types/components/StorageBrowser/views/LocationDetailView/index.d.ts

@@ -1,3 +1,3 @@
 export { LocationDetailView } from './LocationDetailView';
-export { LocationDetailViewProps, LocationDetailViewType } from './types';
+export { LocationDetailViewProps, LocationDetailViewState, LocationDetailViewType, } from './types';
 export { useLocationDetailView } from './useLocationDetailView';

package/dist/types/components/StorageBrowser/views/LocationsView/index.d.ts

@@ -1,3 +1,3 @@
 export { LocationsView } from './LocationsView';
-export { LocationsViewProps, LocationsViewType } from './types';
+export { LocationsViewProps, LocationsViewState, LocationsViewType, } from './types';
 export { useLocationsView } from './useLocationsView';

package/dist/types/components/StorageBrowser/views/context/getViews.d.ts

@@ -1,4 +1,4 @@
 import { CustomActionConfigs } from '../../actions';
-import { Views } from '../types';
+import { StorageBrowserViews } from '../types';
 import { ViewsContextType } from './types';
-export declare const getViews: (views?: Views, customConfigs?: CustomActionConfigs) => ViewsContextType;
+export declare const getViews: (views?: StorageBrowserViews, customConfigs?: CustomActionConfigs) => ViewsContextType;

package/dist/types/components/StorageBrowser/views/context/views.d.ts

@@ -1,10 +1,10 @@
 import React from 'react';
 import { ExtendedActionConfigs } from '../../actions';
-import { Views } from '../types';
+import { StorageBrowserViews } from '../types';
 import { ViewsContextType } from './types';
 export declare function ViewsProvider({ children, views, actions, }: {
     children?: React.ReactNode;
     actions?: ExtendedActionConfigs;
-    views?: Views;
+    views?: StorageBrowserViews;
 }): React.JSX.Element;
 export declare function useViews(): ViewsContextType;

package/dist/types/components/StorageBrowser/views/hooks/usePaginate.d.ts

@@ -1,15 +1,15 @@
-interface UsePaginate<T> {
+interface UsePaginateState<T> {
     currentPage: number;
     highestPageVisited: number;
-    onPaginate: (page: number) => void;
+    handlePaginate: (page: number) => void;
     handleReset: () => void;
     pageItems: T[];
 }
-interface UsePaginateProps<T> {
-    hasNextToken: boolean;
-    items: T[];
-    paginateCallback?: () => void;
-    pageSize: number;
+interface UsePaginateInput<T> {
+    items?: T[];
+    onPaginate?: (page?: number) => void;
+    page?: number;
+    pageSize?: number;
 }
-export declare const usePaginate: <T>({ hasNextToken, items, paginateCallback, pageSize, }: UsePaginateProps<T>) => UsePaginate<T>;
+export declare const usePaginate: <T>({ items, onPaginate, page, pageSize, }: UsePaginateInput<T>) => UsePaginateState<T>;
 export {};

package/dist/types/components/StorageBrowser/views/hooks/useResolveTableData/index.d.ts

@@ -0,0 +1,2 @@
+export { default as useResolveTableData } from './useResolveTableData';
+export { DataTableResolvers } from './types';

package/dist/types/components/StorageBrowser/views/hooks/useResolveTableData/types.d.ts

@@ -0,0 +1,26 @@
+import { WithKey } from '../../../components/types';
+import { DataTableHeader, DataTableDataCell } from '../../../composables/DataTable';
+interface ResolverProps<P> {
+    /**
+     * additional props provided from consumer
+     */
+    props: P;
+}
+type ResolveData<TData, TDataCell> = (data: TData) => WithKey<TDataCell>;
+export interface CellData<TProps, TItem> extends ResolverProps<TProps> {
+    /**
+     * cell item
+     */
+    item: TItem;
+}
+export type GetCell<K, TProps, TItem> = ResolveData<WithKey<CellData<TProps, TItem>, K>, DataTableDataCell>;
+export interface HeaderData<TProps> extends ResolverProps<TProps> {
+}
+export type GetHeader<K, TProps> = ResolveData<WithKey<HeaderData<TProps>, K>, DataTableHeader>;
+export type GetRowKey<TProps, TItem> = (data: CellData<TProps, TItem>) => string;
+export interface DataTableResolvers<K, TProps, TItem> {
+    getCell: GetCell<K, TProps, TItem>;
+    getHeader: GetHeader<K, TProps>;
+    getRowKey: GetRowKey<TProps, TItem>;
+}
+export {};

package/dist/types/components/StorageBrowser/views/hooks/useResolveTableData/useResolveTableData.d.ts

@@ -0,0 +1,6 @@
+import { DataTableProps } from '../../../composables/DataTable';
+import { DataTableResolvers } from './types';
+export default function useResolveDataTable<K extends string, TItem = {}, TProps = {}>(keys: readonly K[] | K[], { getCell, getHeader, getRowKey }: DataTableResolvers<K, TProps, TItem>, { items, props }: {
+    items?: TItem[];
+    props: TProps;
+}): DataTableProps;