@atlaskit/link-datasource 4.20.0 → 4.20.2

package/dist/types/ui/issue-like-table/types.d.ts

@@ -24,11 +24,10 @@ export interface ColumnSizesMap {
     [key: string]: number;
 }
 export interface IssueLikeDataTableViewProps {
-    testId?: string;
     /**
-     * Datasource extension key. Optional as value may not have been returned yet
+     * Map of column key to custom column width
      */
-    extensionKey?: string | null;
+    columnCustomSizes?: ColumnSizesMap;
     /**
      * All available columns/properties.
      * Consumer should not reorder these columns to align with `visibleColumnKeys`.
@@ -36,15 +35,29 @@ export interface IssueLikeDataTableViewProps {
      */
     columns: DatasourceResponseSchemaProperty[];
     /**
-     * List of properties/column keys that are visible/selected
+     * Datasource extension key. Optional as value may not have been returned yet
      */
-    visibleColumnKeys: string[];
+    extensionKey?: string | null;
     hasNextPage: boolean;
-    status: DatasourceTableStatusType;
-    items: DatasourceDataResponseItem[];
     itemIds: string[];
-    onNextPage: NextPageType;
+    items: DatasourceDataResponseItem[];
+    onColumnResize?: (key: string, width: number) => void;
     onLoadDatasourceDetails: () => Promise<void>;
+    onNextPage: NextPageType;
+    /**
+     * Callback to be invoked whenever a user changes the visible columns in a datasource table
+     * either by selecting/unselecting or reordering (drag and drop)
+     *
+     * @param visibleColumnKeys the array of keys for all of the selected columns
+     */
+    onVisibleColumnKeysChange?: (visibleColumnKeys: string[]) => void;
+    /**
+     * Callback to be invoked whenever user changes wrap attribute of the column.
+     *
+     * @param key Column key
+     * @param shouldWrap  Whenever column should wrap
+     */
+    onWrappedColumnChange?: (key: string, shouldWrap: boolean) => void;
     /**
      * A function to define new or override existing render components.
      * eg:
@@ -58,40 +71,27 @@ export interface IssueLikeDataTableViewProps {
      * };
      */
     renderItem?: TableViewPropsRenderType;
-    /**
-     * Callback to be invoked whenever a user changes the visible columns in a datasource table
-     * either by selecting/unselecting or reordering (drag and drop)
-     *
-     * @param visibleColumnKeys the array of keys for all of the selected columns
-     */
-    onVisibleColumnKeysChange?: (visibleColumnKeys: string[]) => void;
     /**
      * If this number is set it will restrict (max-height) maximum size of the component AND make main container a scrollable container.
      * It this number is undefined it will not restrict height and not make container scrollable.
      */
     scrollableContainerHeight?: number;
+    status: DatasourceTableStatusType;
+    testId?: string;
     /**
-     * Map of column key to custom column width
+     * List of properties/column keys that are visible/selected
      */
-    columnCustomSizes?: ColumnSizesMap;
-    onColumnResize?: (key: string, width: number) => void;
+    visibleColumnKeys: string[];
     /**
      * List of column keys that needs to be shown without truncation (content will wrap to a new line)
      */
     wrappedColumnKeys?: string[];
-    /**
-     * Callback to be invoked whenever user changes wrap attribute of the column.
-     *
-     * @param key Column key
-     * @param shouldWrap  Whenever column should wrap
-     */
-    onWrappedColumnChange?: (key: string, shouldWrap: boolean) => void;
 }
 export interface HeaderRowCellType {
+    content?: React.ReactNode | string;
     key: string;
-    width?: number;
     shouldTruncate?: boolean;
-    content?: React.ReactNode | string;
+    width?: number;
 }
 export interface RowType {
     cells: Array<RowCellType>;
@@ -99,9 +99,9 @@ export interface RowType {
     ref?: Ref<HTMLTableRowElement>;
 }
 export interface RowCellType {
+    content?: React.ReactNode | string;
     key: string;
+    shouldTruncate?: boolean;
     type?: DatasourceType['type'];
     width?: number;
-    shouldTruncate?: boolean;
-    content?: React.ReactNode | string;
 }

package/dist/types/ui/jira-issues-modal/basic-filters/hooks/useFilterOptions.d.ts

@@ -11,13 +11,13 @@ export interface FetchFilterOptionsProps {
     searchString?: string;
 }
 export interface FilterOptionsState {
-    filterOptions: SelectOption[];
+    errors: unknown[];
     fetchFilterOptions: (prop?: FetchFilterOptionsProps) => Promise<void>;
-    reset: () => void;
-    totalCount: number;
+    filterOptions: SelectOption[];
     pageCursor?: string;
+    reset: () => void;
     status: 'empty' | 'loading' | 'resolved' | 'rejected' | 'loadingMore';
-    errors: unknown[];
+    totalCount: number;
 }
 export declare const getAssigneeUnassignedFilterOption: (formatMessage: IntlShape["formatMessage"]) => AvatarLabelOption;
 export declare const useFilterOptions: ({ filterType, site }: FilterOptionsProps) => FilterOptionsState;

package/dist/types/ui/jira-issues-modal/basic-filters/hooks/useHydrateJqlQuery.d.ts

@@ -1,9 +1,9 @@
 import { type CommonBasicFilterHookState } from '../../../common/modal/popup-select/types';
 import { type SelectedOptionsMap } from '../types';
 export interface HydrateJqlState extends CommonBasicFilterHookState {
+    fetchHydratedJqlOptions: () => Promise<void>;
     hydratedOptions: SelectedOptionsMap & {
         basicInputTextValue?: string;
     };
-    fetchHydratedJqlOptions: () => Promise<void>;
 }
 export declare const useHydrateJqlQuery: (cloudId: string, jql: string) => HydrateJqlState;

package/dist/types/ui/jira-issues-modal/basic-filters/types.d.ts

@@ -33,13 +33,13 @@ type HydrateJqlQueryBody = {
 };
 type FieldValuesBody = {
     fieldValues: {
-        totalCount: number;
-        pageInfo: {
-            endCursor?: string;
-        };
         edges: Array<{
             node: AggJqlBuilderFieldNode;
         }>;
+        pageInfo: {
+            endCursor?: string;
+        };
+        totalCount: number;
     };
 };
 type JqlBuilderProject = {
@@ -62,13 +62,13 @@ type JqlBuilderStatusCategory = {
     colorName: string;
 };
 export type AggJqlBuilderFieldNode = {
-    jqlTerm: string;
     displayName: string;
-    project?: JqlBuilderProject;
-    user?: JqlBuilderUser;
+    group?: JqlBuilderGroup;
     issueTypes?: Array<JqlBuilderIssueType>;
+    jqlTerm: string;
+    project?: JqlBuilderProject;
     statusCategory?: JqlBuilderStatusCategory;
-    group?: JqlBuilderGroup;
+    user?: JqlBuilderUser;
 };
 export type HydrateResponse = JQLBuilderResponse<HydrateJqlQueryBody>;
 export type FieldValuesResponse = JQLBuilderResponse<FieldValuesBody>;

package/dist/types/ui/jira-issues-modal/basic-filters/ui/async-popup-select/index.d.ts

@@ -4,10 +4,10 @@ import { type SelectOption } from '../../../../common/modal/popup-select/types';
 import { type BasicFilterFieldType } from '../../types';
 export interface AsyncPopupSelectProps {
     filterType: BasicFilterFieldType;
-    selection: SelectOption[];
+    isDisabled?: boolean;
     isJQLHydrating: boolean;
     onSelectionChange?: (filterType: BasicFilterFieldType, options: SelectOption[]) => void;
-    isDisabled?: boolean;
+    selection: SelectOption[];
     site?: Site;
 }
 declare const AsyncPopupSelect: ({ filterType, site, selection, isJQLHydrating, onSelectionChange, isDisabled, }: AsyncPopupSelectProps) => React.JSX.Element;

package/dist/types/ui/jira-issues-modal/basic-filters/ui/index.d.ts

@@ -4,11 +4,11 @@ import { type SelectOption } from '../../../common/modal/popup-select/types';
 import type { BasicFilterFieldType, SelectedOptionsMap } from '../types';
 export declare const availableBasicFilterTypes: BasicFilterFieldType[];
 export interface BasicFilterContainerProps {
+    isJQLHydrating: boolean;
     jql: string;
-    site?: Site;
-    selections: SelectedOptionsMap;
     onChange: (filterType: BasicFilterFieldType, options: SelectOption[]) => void;
-    isJQLHydrating: boolean;
+    selections: SelectedOptionsMap;
+    site?: Site;
 }
 declare const BasicFilterContainer: ({ jql, site, onChange, selections, isJQLHydrating, }: BasicFilterContainerProps) => React.JSX.Element;
 export default BasicFilterContainer;

package/dist/types/ui/jira-issues-modal/jira-search-container/buildJQL.d.ts

@@ -1,9 +1,9 @@
 import { type SelectedOptionsMap } from '../basic-filters/types';
 type BuildJQLInput = {
-    rawSearch: string;
+    filterValues?: SelectedOptionsMap;
     orderDirection?: string;
     orderKey?: string;
-    filterValues?: SelectedOptionsMap;
+    rawSearch: string;
 };
 export declare const fuzzyCharacter = "*";
 export declare const buildJQL: (input: BuildJQLInput) => string;

package/dist/types/ui/jira-issues-modal/jira-search-container/index.d.ts

@@ -4,13 +4,13 @@ import { type JiraIssueDatasourceParameters, type JiraIssueDatasourceParametersQ
 export declare const DEFAULT_JQL_QUERY = "ORDER BY created DESC";
 export declare const ALLOWED_ORDER_BY_KEYS: string[];
 export interface SearchContainerProps {
+    initialSearchMethod: JiraSearchMethod;
     isSearching?: boolean;
     onSearch: (query: JiraIssueDatasourceParametersQuery, { searchMethod, basicFilterSelections, }: {
-        searchMethod: JiraSearchMethod;
         basicFilterSelections: SelectedOptionsMap;
         isQueryComplex: boolean;
+        searchMethod: JiraSearchMethod;
     }) => void;
-    initialSearchMethod: JiraSearchMethod;
     onSearchMethodChange: (searchMethod: JiraSearchMethod) => void;
     parameters?: JiraIssueDatasourceParameters;
     searchBarJql?: string;

package/dist/types/ui/table-footer/index.d.ts

@@ -1,8 +1,8 @@
 export type TableFooterProps = {
     datasourceId: string;
+    isLoading: boolean;
     itemCount?: number;
     onRefresh?: () => void;
-    isLoading: boolean;
     url?: string;
 };
 export declare const TableFooter: ({ datasourceId, itemCount, onRefresh, isLoading, url, }: TableFooterProps) => JSX.Element | null;

package/dist/types-ts4.5/analytics/ufoExperiences/hooks/useDataRenderedUfoExperience.d.ts

@@ -1,10 +1,10 @@
 import { type DatasourceTableStatusType } from '@atlaskit/linking-types';
 interface DataRenderedUfoExperienceProps {
-    status: DatasourceTableStatusType;
-    experienceId: string;
-    itemCount: number;
     canBeLink?: boolean;
+    experienceId: string;
     extensionKey?: string | null;
+    itemCount: number;
+    status: DatasourceTableStatusType;
 }
 /**
  * Hook to mark DataRendered UFO experience as either Success or Failure

package/dist/types-ts4.5/analytics/ufoExperiences/types.d.ts

@@ -1,20 +1,20 @@
 interface DatasourceRendered {
-    name: 'datasource-rendered';
     metadata?: {
         extensionKey?: string;
     };
+    name: 'datasource-rendered';
 }
 interface ColumnPickerRendered {
-    name: 'column-picker-rendered';
     metadata?: {
         extensionKey?: string;
     };
+    name: 'column-picker-rendered';
 }
 interface InlineEditRendered {
-    name: 'inline-edit-rendered';
     metadata?: {
         extensionKey?: string;
     };
+    name: 'inline-edit-rendered';
 }
 export type UfoExperience = DatasourceRendered | ColumnPickerRendered | InlineEditRendered;
 export {};

package/dist/types-ts4.5/common/types.d.ts

@@ -13,26 +13,26 @@ export type OnInsertFunction<ADF> = (adf: ADF, analyticsEvent?: UIAnalyticsEvent
 export type ConfigModalProps<ADF, Parameters> = {
     /** Unique identifier for which type of datasource is being rendered and for making its requests */
     datasourceId: string;
-    /** The url that was used to insert a List of Links */
-    url?: string;
-    /** Parameters for making the data requests necessary to render data within the table */
-    parameters?: Parameters;
+    /** Disable the view mode display dropdown */
+    disableDisplayDropdown?: boolean;
     /** Callback function to be invoked when the modal is closed either via cancel button click, esc keydown, or modal blanket click */
     onCancel: () => void;
     /** Callback function to be invoked when the insert issues button is clicked */
     onInsert: OnInsertFunction<ADF>;
+    /** Parameters for making the data requests necessary to render data within the table */
+    parameters?: Parameters;
+    /**
+     * Set the focus to return to the element that had focus before focus lock was activated or pass through a specific ref element
+     * Defaults to false, meaning focus remains where it was when the FocusLock was deactivated
+     */
+    shouldReturnFocus?: ShouldReturnFocus;
+    /** The url that was used to insert a List of Links */
+    url?: string;
     /**
      * The view mode that the modal will show on open:
      * - Table = Displays a list of links in table format
      * - Inline = Presents a smart link that shows the count of query results. However, if there's only one result, it converts to an inline smart link of that issue.
      */
     viewMode?: DisplayViewModes;
-    /** Disable the view mode display dropdown */
-    disableDisplayDropdown?: boolean;
-    /**
-     * Set the focus to return to the element that had focus before focus lock was activated or pass through a specific ref element
-     * Defaults to false, meaning focus remains where it was when the FocusLock was deactivated
-     */
-    shouldReturnFocus?: ShouldReturnFocus;
 } & Partial<Pick<IssueLikeDataTableViewProps, 'visibleColumnKeys' | 'wrappedColumnKeys' | 'columnCustomSizes'>>;
 export {};

package/dist/types-ts4.5/common/ui/common/render-svg.d.ts

@@ -3,13 +3,13 @@
  * @jsx jsx
  */
 export type RenderSVGProps = {
-    size?: 'xlarge' | 'large' | 'medium';
     alt: string;
+    size?: 'xlarge' | 'large' | 'medium';
 };
 type RenderSVGInternalProps = RenderSVGProps & {
+    className?: string;
     src: string;
     srcDark?: string;
-    className?: string;
 };
 export declare const RenderSVG: ({ alt, size, src, srcDark }: RenderSVGInternalProps) => JSX.Element;
 export {};

package/dist/types-ts4.5/hooks/useAssetsClient.d.ts

@@ -1,13 +1,13 @@
 import { type ObjectSchema } from '../types/assets/types';
 import { type AssetsDatasourceParameters } from '../ui/assets-modal/types';
 export type UseAssetsClientState = {
-    workspaceId: string | undefined;
-    workspaceError: Error | undefined;
+    assetsClientLoading: boolean;
     existingObjectSchema: ObjectSchema | undefined;
     existingObjectSchemaError: Error | undefined;
     objectSchemas: ObjectSchema[] | undefined;
     objectSchemasError: Error | undefined;
     totalObjectSchemas: number | undefined;
-    assetsClientLoading: boolean;
+    workspaceError: Error | undefined;
+    workspaceId: string | undefined;
 };
 export declare const useAssetsClient: (initialParameters?: AssetsDatasourceParameters) => UseAssetsClientState;

package/dist/types-ts4.5/hooks/useDatasourceTableFlag.d.ts

@@ -1,7 +1,7 @@
 import { type CreateFlagArgs } from '@atlaskit/flag';
 interface DatasourceTableFlagOptions {
-    url?: string;
     isFetchAction?: boolean;
+    url?: string;
 }
 export declare const useDatasourceTableFlag: (options?: DatasourceTableFlagOptions) => {
     showErrorFlag: (args?: Partial<CreateFlagArgs> & {

package/dist/types-ts4.5/hooks/useDatasourceTableState.d.ts

@@ -1,8 +1,8 @@
 import { type DatasourceDataResponseItem, type DatasourceMeta, type DatasourceParameters, type DatasourceResponseSchemaProperty, type DatasourceTableStatusType } from '@atlaskit/linking-types';
 export interface onNextPageProps {
     isSchemaFromData?: boolean;
-    shouldRequestFirstPage?: boolean;
     shouldForceRequest?: boolean;
+    shouldRequestFirstPage?: boolean;
 }
 export type NextPageType = (requestInfo?: onNextPageProps) => void;
 interface ResetOptions {
@@ -12,42 +12,42 @@ interface ResetOptions {
     shouldResetColumns?: boolean;
 }
 export interface DatasourceTableState {
-    /** The current status of the table for rendering of the different UI states (e.g.: loading, error, etc). */
-    status: DatasourceTableStatusType;
-    /** Requests the available data with pagination and also sets column headers if not already available */
-    onNextPage: NextPageType;
-    /** Resets state of the hook to be as if it is a first time it is being called. */
-    reset: (options?: ResetOptions) => void;
-    /** Requests the available column schemas that can be displayed within the table */
-    loadDatasourceDetails: () => Promise<void>;
-    /** Item ids to be hydrated from a store by consumers [NOTE: They must be in the same order as responseItems] */
-    responseItemIds: string[];
-    /** Items to be rendered within the table */
-    responseItems: DatasourceDataResponseItem[];
-    /** Indicates whether there is still more data that can be paginated */
-    hasNextPage: boolean;
+    /** Auth info used to connect to the provider account. */
+    authDetails?: DatasourceMeta['auth'];
     /** All available columns for a datasource table to display */
     columns: DatasourceResponseSchemaProperty[];
     /** The keys belonging to all of the currently visible columns in a table */
     defaultVisibleColumnKeys: string[];
-    /** Total count of response items available for pagination in a query */
-    totalCount?: number;
     /** List of objects types that will be included in the reponse (e.g. 'issues' for Jira) */
     destinationObjectTypes: string[];
     /** Used as an indicated of which provider type is being used - originates from ORS */
     extensionKey?: string;
+    /** Indicates whether there is still more data that can be paginated */
+    hasNextPage: boolean;
+    /** Requests the available column schemas that can be displayed within the table */
+    loadDatasourceDetails: () => Promise<void>;
+    /** Requests the available data with pagination and also sets column headers if not already available */
+    onNextPage: NextPageType;
     /** Indicates which provider name is being used - originates from ORS */
     providerName?: string;
-    /** Auth info used to connect to the provider account. */
-    authDetails?: DatasourceMeta['auth'];
+    /** Resets state of the hook to be as if it is a first time it is being called. */
+    reset: (options?: ResetOptions) => void;
+    /** Item ids to be hydrated from a store by consumers [NOTE: They must be in the same order as responseItems] */
+    responseItemIds: string[];
+    /** Items to be rendered within the table */
+    responseItems: DatasourceDataResponseItem[];
+    /** The current status of the table for rendering of the different UI states (e.g.: loading, error, etc). */
+    status: DatasourceTableStatusType;
+    /** Total count of response items available for pagination in a query */
+    totalCount?: number;
 }
 export interface DatasourceTableStateProps {
     /** Unique identifier for which type of datasource is being rendered and for making its requests */
     datasourceId: string;
-    /** Parameters for making the data requests necessary to render data within the table */
-    parameters?: DatasourceParameters;
     /** Keys for each of the columns to be shown in the table */
     fieldKeys?: string[];
+    /** Parameters for making the data requests necessary to render data within the table */
+    parameters?: DatasourceParameters;
 }
 export declare const useDatasourceTableState: ({ datasourceId, parameters, fieldKeys, }: DatasourceTableStateProps) => DatasourceTableState;
 export {};

package/dist/types-ts4.5/hooks/useLoadOptions.d.ts

@@ -1,9 +1,9 @@
 import { type AtomicActionExecuteRequest } from '@atlaskit/linking-types';
 import type { ExecuteFetch } from '../state/actions';
 export type LoadOptionsProps<T> = {
-    fetchInputs?: AtomicActionExecuteRequest['parameters']['inputs'];
-    executeFetch?: ExecuteFetch;
     emptyOption?: T;
+    executeFetch?: ExecuteFetch;
+    fetchInputs?: AtomicActionExecuteRequest['parameters']['inputs'];
 };
 export declare const useLoadOptions: <T>({ fetchInputs, executeFetch, emptyOption, }: LoadOptionsProps<T>) => {
     options: T[];

package/dist/types-ts4.5/hooks/useObjectSchemas.d.ts

@@ -1,10 +1,10 @@
 import { type ObjectSchema } from '../types/assets/types';
 export type FetchObjectSchemasDetails = Pick<UseObjectSchemasState, 'objectSchemas' | 'totalObjectSchemas'>;
 export type UseObjectSchemasState = {
-    objectSchemasLoading: boolean;
-    objectSchemasError: Error | undefined;
+    fetchObjectSchemas: (query: string) => Promise<FetchObjectSchemasDetails>;
     objectSchemas: ObjectSchema[] | undefined;
+    objectSchemasError: Error | undefined;
+    objectSchemasLoading: boolean;
     totalObjectSchemas: number | undefined;
-    fetchObjectSchemas: (query: string) => Promise<FetchObjectSchemasDetails>;
 };
 export declare const useObjectSchemas: (workspaceId: string) => UseObjectSchemasState;

package/dist/types-ts4.5/hooks/useValidateAqlText.d.ts

@@ -9,8 +9,8 @@ export type ValidResult = {
     validatedAql: string;
 };
 export type InvalidResult = {
-    type: 'invalid';
     error: string;
+    type: 'invalid';
 };
 export type AqlValidationResult = IdleResult | LoadingResult | ValidResult | InvalidResult;
 export type AqlValidationResponse = {
@@ -19,8 +19,8 @@ export type AqlValidationResponse = {
 };
 export type UseValidateAqlTextState = {
     debouncedValidation: (value: string | undefined) => Promise<string | undefined>;
-    validateAqlText: (aql: string) => Promise<'error' | undefined>;
     lastValidationResult: AqlValidationResult;
+    validateAqlText: (aql: string) => Promise<'error' | undefined>;
 };
 export declare const SEARCH_DEBOUNCE = 350;
 export declare const useValidateAqlText: (workspaceId: string, initialValue: string) => UseValidateAqlTextState;

package/dist/types-ts4.5/i18n/en.d.ts

@@ -79,6 +79,7 @@ declare const _default: {
     'linkDataSource.confluence-search.no.confluence.sites.access.title': string;
     'linkDataSource.datasource.table.authConnectButtonText': string;
     'linkDataSource.datasource.table.authScreenDescriptionText': string;
+    'linkDataSource.datasource.table.authScreenDescriptionText-appify': string;
     'linkDataSource.datasource.table.authScreenHeaderText': string;
     'linkDataSource.datasource.table.learnMoreAboutSmartLinks': string;
     'linkDataSource.issue-line-table.edit-button-label.non-final': string;

package/dist/types-ts4.5/i18n/en_GB.d.ts

@@ -79,6 +79,7 @@ declare const _default: {
     'linkDataSource.confluence-search.no.confluence.sites.access.title': string;
     'linkDataSource.datasource.table.authConnectButtonText': string;
     'linkDataSource.datasource.table.authScreenDescriptionText': string;
+    'linkDataSource.datasource.table.authScreenDescriptionText-appify': string;
     'linkDataSource.datasource.table.authScreenHeaderText': string;
     'linkDataSource.datasource.table.learnMoreAboutSmartLinks': string;
     'linkDataSource.issue-line-table.edit-button-label.non-final': string;

package/dist/types-ts4.5/i18n/en_ZZ.d.ts

@@ -79,6 +79,7 @@ declare const _default: {
     'linkDataSource.confluence-search.no.confluence.sites.access.title': string;
     'linkDataSource.datasource.table.authConnectButtonText': string;
     'linkDataSource.datasource.table.authScreenDescriptionText': string;
+    'linkDataSource.datasource.table.authScreenDescriptionText-appify': string;
     'linkDataSource.datasource.table.authScreenHeaderText': string;
     'linkDataSource.datasource.table.learnMoreAboutSmartLinks': string;
     'linkDataSource.issue-line-table.edit-button-label.non-final': string;

package/dist/types-ts4.5/services/useBasicFilterAGG.d.ts

@@ -4,8 +4,8 @@ interface GetFieldValuesProps {
     cloudId: string;
     jql: string;
     jqlTerm: BasicFilterFieldType;
-    searchString: string;
     pageCursor?: string;
+    searchString: string;
 }
 export declare const useBasicFilterAGG: () => {
     getHydratedJQL: (cloudId: string, jql: string) => Promise<HydrateResponse>;

package/dist/types-ts4.5/state/index.d.ts

@@ -4,9 +4,9 @@ import type { DatasourceDataResponseItem } from '@atlaskit/linking-types';
 type UniqueIdentifier = string;
 export interface DatasourceItem {
     ari: string | undefined;
+    data: DatasourceDataResponseItem;
     entityType: string | undefined;
     integrationKey: string | undefined;
-    data: DatasourceDataResponseItem;
 }
 export interface State {
     items: Record<UniqueIdentifier, DatasourceItem>;

package/dist/types-ts4.5/types/assets/types.d.ts

@@ -15,23 +15,23 @@ export type ObjectSchemaOption = {
 };
 export type FetchObjectSchemaResponse = ObjectSchema;
 export type FetchObjectSchemasResponse = {
-    startAt: number;
+    isLast: boolean;
     maxResults: number;
+    startAt: number;
     total: number;
     values: ObjectSchema[];
-    isLast: boolean;
 };
 export type ValidationError = {
     iql?: string;
 };
 export type AqlValidateResponse = {
-    isValid: boolean;
     errorMessages: string[];
     errors?: ValidationError;
+    isValid: boolean;
 };
 export declare const objectSchemaKey: "objectSchema";
 export declare const aqlKey: "aql";
 export type SearchForm = {
-    [objectSchemaKey]: ObjectSchemaOption | undefined | null;
     [aqlKey]: string;
+    [objectSchemaKey]: ObjectSchemaOption | undefined | null;
 };

package/dist/types-ts4.5/ui/assets-modal/modal/render-assets-content/index.d.ts

@@ -1,19 +1,19 @@
 import { type DatasourceDataResponseItem, type DatasourceResponseSchemaProperty, type DatasourceTableStatusType } from '@atlaskit/linking-types';
 export interface RenderAssetsContentProps {
-    isFetchingInitialData: boolean;
-    status: DatasourceTableStatusType;
-    responseItems: DatasourceDataResponseItem[];
-    responseItemIds: string[];
-    visibleColumnKeys?: string[];
-    datasourceId: string;
     aql?: string;
-    schemaId?: string;
-    onNextPage: () => void;
-    hasNextPage: boolean;
-    loadDatasourceDetails: () => Promise<void>;
     columns: DatasourceResponseSchemaProperty[];
+    datasourceId: string;
     defaultVisibleColumnKeys: string[];
+    hasNextPage: boolean;
+    isFetchingInitialData: boolean;
+    loadDatasourceDetails: () => Promise<void>;
+    onNextPage: () => void;
     onVisibleColumnKeysChange: (visibleColumnKeys: string[]) => void;
+    responseItemIds: string[];
+    responseItems: DatasourceDataResponseItem[];
+    schemaId?: string;
+    status: DatasourceTableStatusType;
+    visibleColumnKeys?: string[];
 }
 export declare const MODAL_HEIGHT = 420;
 export declare const RenderAssetsContent: (props: RenderAssetsContentProps) => JSX.Element;

package/dist/types-ts4.5/ui/assets-modal/search-container/aql-search-input/index.d.ts

@@ -1,7 +1,7 @@
 export interface AqlSearchInputProps {
+    isSearching: boolean;
+    testId?: string;
     value: string;
     workspaceId: string;
-    testId?: string;
-    isSearching: boolean;
 }
 export declare const AqlSearchInput: ({ value, workspaceId, testId, isSearching, }: AqlSearchInputProps) => JSX.Element;

package/dist/types-ts4.5/ui/assets-modal/search-container/index.d.ts

@@ -1,14 +1,14 @@
 import type { ObjectSchema } from '../../../types/assets/types';
 export type InitialSearchData = {
+    aql?: string;
     objectSchema?: ObjectSchema;
     objectSchemas?: ObjectSchema[];
-    aql?: string;
 };
 export interface SearchContainerProps {
-    workspaceId: string;
     initialSearchData: InitialSearchData;
-    onSearch: (aql: string, schemaId: string) => void;
-    modalTitle?: JSX.Element;
     isSearching: boolean;
+    modalTitle?: JSX.Element;
+    onSearch: (aql: string, schemaId: string) => void;
+    workspaceId: string;
 }
 export declare const AssetsSearchContainer: (props: SearchContainerProps) => JSX.Element;

package/dist/types-ts4.5/ui/assets-modal/search-container/object-schema-select/index.d.ts

@@ -4,11 +4,11 @@
  */
 import { type ObjectSchema } from '../../../../types/assets/types';
 type AssetsObjectSchemaSelectProps = {
-    value: ObjectSchema | undefined;
-    workspaceId: string;
-    initialObjectSchemas: ObjectSchema[] | undefined;
     classNamePrefix?: string;
+    initialObjectSchemas: ObjectSchema[] | undefined;
     testId?: string;
+    value: ObjectSchema | undefined;
+    workspaceId: string;
 };
 export declare const SEARCH_DEBOUNCE_MS = 350;
 /**