/// <reference types="react" />

import { ApiRef } from '@backstage/core-plugin-api';
import { AutocompleteProps } from '@material-ui/lab/Autocomplete';
import { CATALOG_FILTER_EXISTS } from '@backstage/catalog-client';
import { CatalogApi } from '@backstage/catalog-client';
import { ComponentEntity } from '@backstage/catalog-model';
import { ComponentProps } from 'react';
import { CompoundEntityRef } from '@backstage/catalog-model';
import { Entity } from '@backstage/catalog-model';
import IconButton from '@material-ui/core/IconButton';
import { IconComponent } from '@backstage/core-plugin-api';
import { InfoCardVariants } from '@backstage/core-components';
import { LinkProps } from '@backstage/core-components';
import { Observable } from '@backstage/types';
import { OutlinedTextFieldProps } from '@material-ui/core/TextField';
import { Overrides } from '@material-ui/core/styles/overrides';
import { PropsWithChildren } from 'react';
import { default as React_2 } from 'react';
import { ReactNode } from 'react';
import { RouteRef } from '@backstage/core-plugin-api';
import { scmIntegrationsApiRef } from '@backstage/integration-react';
import { StyleRules } from '@material-ui/core/styles/withStyles';
import { SystemEntity } from '@backstage/catalog-model';
import { TableColumn } from '@backstage/core-components';
import { TableOptions } from '@backstage/core-components';
import { TextFieldProps } from '@material-ui/core/TextField';
import { TypographyProps } from '@material-ui/core/Typography';

// @public (undocumented)
export type AllowedEntityFilters<T extends DefaultEntityFilters> = {
  [K in keyof T]-?: NonNullable<T[K]> extends EntityFilter & {
    values: string[];
  }
    ? K
    : never;
}[keyof T];

// @public
export const AsyncEntityProvider: (
  props: AsyncEntityProviderProps,
) => React_2.JSX.Element;

// @public
export interface AsyncEntityProviderProps {
  // (undocumented)
  children: ReactNode;
  // (undocumented)
  entity?: Entity;
  // (undocumented)
  error?: Error;
  // (undocumented)
  loading: boolean;
  // (undocumented)
  refresh?: VoidFunction;
}

// @public (undocumented)
export type BackstageOverrides = Overrides & {
  [Name in keyof CatalogReactComponentsNameToClassKey]?: Partial<
    StyleRules<CatalogReactComponentsNameToClassKey[Name]>
  >;
};

export { CATALOG_FILTER_EXISTS };

export { CatalogApi };

// @public
export const catalogApiRef: ApiRef<CatalogApi>;

// @public (undocumented)
export function CatalogAutocomplete<
  T,
  Multiple extends boolean | undefined = undefined,
  DisableClearable extends boolean | undefined = undefined,
  FreeSolo extends boolean | undefined = undefined,
>(
  props: CatalogAutocompleteProps<T, Multiple, DisableClearable, FreeSolo>,
): React_2.JSX.Element;

// @public
export type CatalogAutocompleteProps<
  T,
  Multiple extends boolean | undefined = undefined,
  DisableClearable extends boolean | undefined = undefined,
  FreeSolo extends boolean | undefined = undefined,
> = Omit<
  AutocompleteProps<T, Multiple, DisableClearable, FreeSolo>,
  'PopperComponent' | 'PaperComponent' | 'popupIcon' | 'renderInput'
> & {
  name: string;
  label?: string;
  LabelProps?: TypographyProps<'label'>;
  TextFieldProps?: Omit<OutlinedTextFieldProps, 'variant'>;
  renderInput?: AutocompleteProps<
    T,
    Multiple,
    DisableClearable,
    FreeSolo
  >['renderInput'];
};

// @public (undocumented)
export const CatalogFilterLayout: {
  (props: { children: React_2.ReactNode }): React_2.JSX.Element;
  Filters: (props: {
    children: React_2.ReactNode;
    options?: {
      drawerBreakpoint?: 'xs' | 'sm' | 'md' | 'lg' | 'xl' | number;
      drawerAnchor?: 'left' | 'right' | 'top' | 'bottom';
    };
  }) => React_2.JSX.Element;
  Content: (props: { children: React_2.ReactNode }) => React_2.JSX.Element;
};

// @public (undocumented)
export type CatalogReactComponentsNameToClassKey = {
  CatalogReactUserListPicker: CatalogReactUserListPickerClassKey;
  CatalogReactEntityDisplayName: CatalogReactEntityDisplayNameClassKey;
  CatalogReactEntityLifecyclePicker: CatalogReactEntityLifecyclePickerClassKey;
  CatalogReactEntitySearchBar: CatalogReactEntitySearchBarClassKey;
  CatalogReactEntityTagPicker: CatalogReactEntityTagPickerClassKey;
  CatalogReactEntityOwnerPicker: CatalogReactEntityOwnerPickerClassKey;
  CatalogReactFixedWidthFormControlLabel: FixedWidthFormControlLabelClassKey;
  CatalogReactEntityProcessingStatusPicker: CatalogReactEntityProcessingStatusPickerClassKey;
  CatalogReactEntityAutocompletePickerClassKey: CatalogReactEntityAutocompletePickerClassKey;
  CatalogReactMissingAnnotationEmptyState: MissingAnnotationEmptyStateClassKey;
};

// @public (undocumented)
export type CatalogReactEntityAutocompletePickerClassKey = 'root' | 'label';

// @public
export type CatalogReactEntityDisplayNameClassKey = 'root' | 'icon';

// @public (undocumented)
export type CatalogReactEntityLifecyclePickerClassKey = 'input';

// @public (undocumented)
export type CatalogReactEntityNamespacePickerClassKey = 'input';

// @public (undocumented)
export type CatalogReactEntityOwnerPickerClassKey = 'input';

// @public (undocumented)
export type CatalogReactEntityProcessingStatusPickerClassKey = 'input';

// @public (undocumented)
export type CatalogReactEntitySearchBarClassKey = 'searchToolbar' | 'input';

// @public (undocumented)
export type CatalogReactEntityTagPickerClassKey = 'input';

// @public (undocumented)
export type CatalogReactUserListPickerClassKey =
  | 'root'
  | 'title'
  | 'listIcon'
  | 'menuItem'
  | 'groupWrapper';

// @public (undocumented)
export const columnFactories: Readonly<{
  createEntityRefColumn<T extends Entity>(options: {
    defaultKind?: string;
  }): TableColumn<T>;
  createEntityRelationColumn<T_1 extends Entity>(options: {
    title: string;
    relation: string;
    defaultKind?: string;
    filter?: {
      kind: string;
    };
  }): TableColumn<T_1>;
  createOwnerColumn<T_2 extends Entity>(): TableColumn<T_2>;
  createDomainColumn<T_3 extends Entity>(): TableColumn<T_3>;
  createSystemColumn<T_4 extends Entity>(): TableColumn<T_4>;
  createMetadataDescriptionColumn<T_5 extends Entity>(): TableColumn<T_5>;
  createSpecLifecycleColumn<T_6 extends Entity>(): TableColumn<T_6>;
  createSpecTypeColumn<T_7 extends Entity>(): TableColumn<T_7>;
}>;

// @public (undocumented)
export type DefaultEntityFilters = {
  kind?: EntityKindFilter;
  type?: EntityTypeFilter;
  user?: UserListFilter | EntityUserFilter;
  owners?: EntityOwnerFilter;
  lifecycles?: EntityLifecycleFilter;
  tags?: EntityTagFilter;
  text?: EntityTextFilter;
  orphan?: EntityOrphanFilter;
  error?: EntityErrorFilter;
  namespace?: EntityNamespaceFilter;
};

// @public
export function defaultEntityPresentation(
  entityOrRef: Entity | CompoundEntityRef | string,
  context?: {
    defaultKind?: string;
    defaultNamespace?: string;
  },
): EntityRefPresentationSnapshot;

// @public (undocumented)
export const DefaultFilters: (
  props: DefaultFiltersProps,
) => React_2.JSX.Element;

// @public
export type DefaultFiltersProps = {
  initialKind?: string;
  initiallySelectedFilter?: UserListFilterKind;
  ownerPickerMode?: EntityOwnerPickerProps['mode'];
  initiallySelectedNamespaces?: string[];
};

// @public (undocumented)
export function EntityAutocompletePicker<
  T extends DefaultEntityFilters = DefaultEntityFilters,
  Name extends AllowedEntityFilters<T> = AllowedEntityFilters<T>,
>(props: EntityAutocompletePickerProps<T, Name>): React_2.JSX.Element | null;

// @public (undocumented)
export type EntityAutocompletePickerProps<
  T extends DefaultEntityFilters = DefaultEntityFilters,
  Name extends AllowedEntityFilters<T> = AllowedEntityFilters<T>,
> = {
  label: string;
  name: Name;
  path: string;
  showCounts?: boolean;
  Filter: {
    new (values: string[]): NonNullable<T[Name]>;
  };
  InputProps?: TextFieldProps;
  initialSelectedOptions?: string[];
  filtersForAvailableValues?: Array<keyof T>;
  hidden?: boolean;
};

// @public
export const EntityDisplayName: (props: EntityDisplayNameProps) => JSX.Element;

// @public
export type EntityDisplayNameProps = {
  entityRef: Entity | CompoundEntityRef | string;
  hideIcon?: boolean;
  disableTooltip?: boolean;
  defaultKind?: string;
  defaultNamespace?: string;
};

// @public
export class EntityErrorFilter implements EntityFilter {
  constructor(value: boolean);
  // (undocumented)
  filterEntity(entity: Entity): boolean;
  // (undocumented)
  readonly value: boolean;
}

// @public (undocumented)
export type EntityFilter = {
  getCatalogFilters?: () => Record<
    string,
    string | symbol | (string | symbol)[]
  >;
  filterEntity?: (entity: Entity) => boolean;
  toQueryValue?: () => string | string[];
};

// @public
export class EntityKindFilter implements EntityFilter {
  constructor(value: string, label: string);
  // (undocumented)
  getCatalogFilters(): Record<string, string | string[]>;
  // (undocumented)
  readonly label: string;
  // (undocumented)
  toQueryValue(): string;
  // (undocumented)
  readonly value: string;
}

// @public (undocumented)
export const EntityKindPicker: (
  props: EntityKindPickerProps,
) => React_2.JSX.Element | null;

// @public
export interface EntityKindPickerProps {
  allowedKinds?: string[];
  // (undocumented)
  hidden?: boolean;
  // (undocumented)
  initialFilter?: string;
}

// @public
export class EntityLifecycleFilter implements EntityFilter {
  constructor(values: string[]);
  // (undocumented)
  filterEntity(entity: Entity): boolean;
  // (undocumented)
  getCatalogFilters(): Record<string, string | string[]>;
  // (undocumented)
  toQueryValue(): string[];
  // (undocumented)
  readonly values: string[];
}

// @public (undocumented)
export const EntityLifecyclePicker: (props: {
  initialFilter?: string[];
}) => React_2.JSX.Element;

// @public
export const EntityListContext: React_2.Context<
  EntityListContextProps<any> | undefined
>;

// @public (undocumented)
export type EntityListContextProps<
  EntityFilters extends DefaultEntityFilters = DefaultEntityFilters,
> = {
  filters: EntityFilters;
  entities: Entity[];
  backendEntities: Entity[];
  updateFilters: (
    filters:
      | Partial<EntityFilters>
      | ((prevFilters: EntityFilters) => Partial<EntityFilters>),
  ) => void;
  queryParameters: Partial<Record<keyof EntityFilters, string | string[]>>;
  loading: boolean;
  error?: Error;
  pageInfo?: {
    next?: () => void;
    prev?: () => void;
  };
  totalItems?: number;
  limit: number;
  offset?: number;
  setLimit: (limit: number) => void;
  setOffset?: (offset: number) => void;
  paginationMode: PaginationMode;
};

// @public (undocumented)
export type EntityListPagination =
  | boolean
  | {
      mode?: 'cursor';
      limit?: number;
    }
  | {
      mode: 'offset';
      limit?: number;
      offset?: number;
    };

// @public
export const EntityListProvider: <EntityFilters extends DefaultEntityFilters>(
  props: EntityListProviderProps,
) => React_2.JSX.Element;

// @public (undocumented)
export type EntityListProviderProps = PropsWithChildren<{
  pagination?: EntityListPagination;
}>;

// @public (undocumented)
export type EntityLoadingStatus<TEntity extends Entity = Entity> = {
  entity?: TEntity;
  loading: boolean;
  error?: Error;
  refresh?: VoidFunction;
};

// @public
export class EntityNamespaceFilter implements EntityFilter {
  constructor(values: string[]);
  // (undocumented)
  filterEntity(entity: Entity): boolean;
  // (undocumented)
  getCatalogFilters(): Record<string, string | string[]>;
  // (undocumented)
  toQueryValue(): string[];
  // (undocumented)
  readonly values: string[];
}

// @public (undocumented)
export const EntityNamespacePicker: (
  props: EntityNamespacePickerProps,
) => React_2.JSX.Element;

// @public
export interface EntityNamespacePickerProps {
  // (undocumented)
  initiallySelectedNamespaces?: string[];
}

// @public
export class EntityOrphanFilter implements EntityFilter {
  constructor(value: boolean);
  // (undocumented)
  filterEntity(entity: Entity): boolean;
  // (undocumented)
  getCatalogFilters(): Record<string, string | string[]>;
  // (undocumented)
  readonly value: boolean;
}

// @public
export class EntityOwnerFilter implements EntityFilter {
  constructor(values: string[]);
  // (undocumented)
  filterEntity(entity: Entity): boolean;
  // (undocumented)
  getCatalogFilters(): Record<string, string | string[]>;
  toQueryValue(): string[];
  // (undocumented)
  readonly values: string[];
}

// @public (undocumented)
export const EntityOwnerPicker: (
  props?: EntityOwnerPickerProps,
) => React_2.JSX.Element | null;

// @public (undocumented)
export type EntityOwnerPickerProps = {
  mode?: 'owners-only' | 'all';
};

// @public
export const EntityPeekAheadPopover: (
  props: EntityPeekAheadPopoverProps,
) => React_2.JSX.Element;

// @public
export type EntityPeekAheadPopoverProps = PropsWithChildren<{
  entityRef: string;
  delayTime?: number;
}>;

// @public
export interface EntityPresentationApi {
  forEntity(
    entityOrRef: Entity | string,
    context?: {
      defaultKind?: string;
      defaultNamespace?: string;
    },
  ): EntityRefPresentation;
}

// @public
export const entityPresentationApiRef: ApiRef<EntityPresentationApi>;

// @public (undocumented)
export const EntityProcessingStatusPicker: () => React_2.JSX.Element;

// @public
export const EntityProvider: (
  props: EntityProviderProps,
) => React_2.JSX.Element;

// @public
export interface EntityProviderProps {
  // (undocumented)
  children: ReactNode;
  // (undocumented)
  entity?: Entity;
}

// @public
export const EntityRefLink: (props: EntityRefLinkProps) => JSX.Element;

// @public
export type EntityRefLinkProps = {
  entityRef: Entity | CompoundEntityRef | string;
  defaultKind?: string;
  defaultNamespace?: string;
  title?: string;
  children?: React_2.ReactNode;
  hideIcon?: boolean;
  disableTooltip?: boolean;
} & Omit<LinkProps, 'to'>;

// @public
export function EntityRefLinks<
  TRef extends string | CompoundEntityRef | Entity,
>(props: EntityRefLinksProps<TRef>): React_2.JSX.Element;

// @public
export type EntityRefLinksProps<
  TRef extends string | CompoundEntityRef | Entity,
> = {
  defaultKind?: string;
  entityRefs: TRef[];
  hideIcons?: boolean;
  fetchEntities?: boolean;
  getTitle?(entity: TRef): string | undefined;
} & Omit<LinkProps, 'to'>;

// @public
export interface EntityRefPresentation {
  promise: Promise<EntityRefPresentationSnapshot>;
  snapshot: EntityRefPresentationSnapshot;
  update$?: Observable<EntityRefPresentationSnapshot>;
}

// @public
export interface EntityRefPresentationSnapshot {
  entityRef: string;
  Icon?: IconComponent | undefined | false;
  primaryTitle: string;
  secondaryTitle?: string;
}

// @public
export function entityRouteParams(entity: Entity): {
  readonly kind: string;
  readonly namespace: string;
  readonly name: string;
};

// @public
export const entityRouteRef: RouteRef<{
  name: string;
  kind: string;
  namespace: string;
}>;

// @public
export const EntitySearchBar: () => React_2.JSX.Element;

// @public (undocumented)
export type EntitySourceLocation = {
  locationTargetUrl: string;
  integrationType?: string;
};

// @public
export const EntityTable: {
  <T extends Entity>(props: EntityTableProps<T>): React_2.JSX.Element;
  columns: Readonly<{
    createEntityRefColumn<T_1 extends Entity>(options: {
      defaultKind?: string | undefined;
    }): TableColumn<T_1>;
    createEntityRelationColumn<T_2 extends Entity>(options: {
      title: string;
      relation: string;
      defaultKind?: string | undefined;
      filter?:
        | {
            kind: string;
          }
        | undefined;
    }): TableColumn<T_2>;
    createOwnerColumn<T_3 extends Entity>(): TableColumn<T_3>;
    createDomainColumn<T_4 extends Entity>(): TableColumn<T_4>;
    createSystemColumn<T_5 extends Entity>(): TableColumn<T_5>;
    createMetadataDescriptionColumn<T_6 extends Entity>(): TableColumn<T_6>;
    createSpecLifecycleColumn<T_7 extends Entity>(): TableColumn<T_7>;
    createSpecTypeColumn<T_8 extends Entity>(): TableColumn<T_8>;
  }>;
  systemEntityColumns: TableColumn<SystemEntity>[];
  componentEntityColumns: TableColumn<ComponentEntity>[];
};

// @public
export interface EntityTableProps<T extends Entity> {
  // (undocumented)
  columns: TableColumn<T>[];
  // (undocumented)
  emptyContent?: ReactNode;
  // (undocumented)
  entities: T[];
  // (undocumented)
  tableOptions?: TableOptions;
  // (undocumented)
  title: string;
  // (undocumented)
  variant?: InfoCardVariants;
}

// @public
export class EntityTagFilter implements EntityFilter {
  constructor(values: string[]);
  // (undocumented)
  filterEntity(entity: Entity): boolean;
  // (undocumented)
  getCatalogFilters(): Record<string, string | string[]>;
  // (undocumented)
  toQueryValue(): string[];
  // (undocumented)
  readonly values: string[];
}

// @public (undocumented)
export const EntityTagPicker: (
  props: EntityTagPickerProps,
) => React_2.JSX.Element;

// @public (undocumented)
export type EntityTagPickerProps = {
  showCounts?: boolean;
  initialFilter?: string[];
  hidden?: boolean;
};

// @public
export class EntityTextFilter implements EntityFilter {
  constructor(value: string);
  // (undocumented)
  filterEntity(entity: Entity): boolean;
  // (undocumented)
  getFullTextFilters(): {
    term: string;
    fields: string[];
  };
  // (undocumented)
  toQueryValue(): string;
  // (undocumented)
  readonly value: string;
}

// @public
export class EntityTypeFilter implements EntityFilter {
  constructor(value: string | string[]);
  // (undocumented)
  getCatalogFilters(): Record<string, string | string[]>;
  // (undocumented)
  getTypes(): string[];
  // (undocumented)
  toQueryValue(): string[];
  // (undocumented)
  readonly value: string | string[];
}

// @public (undocumented)
export const EntityTypePicker: (
  props: EntityTypePickerProps,
) => React_2.JSX.Element | null;

// @public
export interface EntityTypePickerProps {
  // (undocumented)
  hidden?: boolean;
  // (undocumented)
  initialFilter?: string;
}

// @public (undocumented)
export class EntityUserFilter implements EntityFilter {
  // (undocumented)
  static all(): EntityUserFilter;
  // (undocumented)
  filterEntity(entity: Entity): boolean;
  // (undocumented)
  getCatalogFilters(): Record<string, string[]>;
  // (undocumented)
  static owned(ownershipEntityRefs: string[]): EntityUserFilter;
  // (undocumented)
  readonly refs?: string[] | undefined;
  // (undocumented)
  static starred(starredEntityRefs: string[]): EntityUserFilter;
  // (undocumented)
  toQueryValue(): string;
  // (undocumented)
  readonly value: UserListFilterKind;
}

// @public
export const FavoriteEntity: (
  props: FavoriteEntityProps,
) => React_2.JSX.Element;

// @public (undocumented)
export type FavoriteEntityProps = ComponentProps<typeof IconButton> & {
  entity: Entity;
};

// @public (undocumented)
export type FixedWidthFormControlLabelClassKey = 'label' | 'root';

// @public
export function getEntityRelations(
  entity: Entity | undefined,
  relationType: string,
  filter?: {
    kind: string;
  },
): CompoundEntityRef[];

// @public (undocumented)
export function getEntitySourceLocation(
  entity: Entity,
  scmIntegrationsApi: typeof scmIntegrationsApiRef.T,
): EntitySourceLocation | undefined;

// @public (undocumented)
export function humanizeEntityRef(
  entityRef: Entity | CompoundEntityRef,
  opts?: {
    defaultKind?: string;
    defaultNamespace?: string | false;
  },
): string;

// @public
export function InspectEntityDialog(props: {
  open: boolean;
  entity: Entity;
  initialTab?: 'overview' | 'ancestry' | 'colocated' | 'json' | 'yaml';
  onClose: () => void;
  onSelect?: (tab: string) => void;
}): React_2.JSX.Element | null;

// @public
export function MissingAnnotationEmptyState(props: {
  annotation: string | string[];
  readMoreUrl?: string;
}): React_2.JSX.Element;

// @public (undocumented)
export type MissingAnnotationEmptyStateClassKey = 'code';

// @public @deprecated (undocumented)
export function MockEntityListContextProvider<
  T extends DefaultEntityFilters = DefaultEntityFilters,
>(
  props: PropsWithChildren<{
    value?: Partial<EntityListContextProps<T>>;
  }>,
): React_2.JSX.Element;

// @public
export class MockStarredEntitiesApi implements StarredEntitiesApi {
  // (undocumented)
  starredEntitie$(): Observable<Set<string>>;
  // (undocumented)
  toggleStarred(entityRef: string): Promise<void>;
}

// @public (undocumented)
export type PaginationMode = 'cursor' | 'offset' | 'none';

// @public
export interface StarredEntitiesApi {
  starredEntitie$(): Observable<Set<string>>;
  toggleStarred(entityRef: string): Promise<void>;
}

// @public
export const starredEntitiesApiRef: ApiRef<StarredEntitiesApi>;

// @public (undocumented)
export const UnregisterEntityDialog: (
  props: UnregisterEntityDialogProps,
) => React_2.JSX.Element;

// @public (undocumented)
export type UnregisterEntityDialogProps = {
  open: boolean;
  onConfirm: () => any;
  onClose: () => any;
  entity: Entity;
};

// @public
export function useAsyncEntity<
  TEntity extends Entity = Entity,
>(): EntityLoadingStatus<TEntity>;

// @public
export function useEntity<TEntity extends Entity = Entity>(): {
  entity: TEntity;
};

// @public
export function useEntityList<
  EntityFilters extends DefaultEntityFilters = DefaultEntityFilters,
>(): EntityListContextProps<EntityFilters>;

// @public
export function useEntityOwnership(): {
  loading: boolean;
  isOwnedEntity: (entity: Entity) => boolean;
};

// @public
export function useEntityPresentation(
  entityOrRef: Entity | CompoundEntityRef | string,
  context?: {
    defaultKind?: string;
    defaultNamespace?: string;
  },
): EntityRefPresentationSnapshot;

// @public
export function useEntityTypeFilter(): {
  loading: boolean;
  error?: Error;
  availableTypes: string[];
  selectedTypes: string[];
  setSelectedTypes: (types: string[]) => void;
};

// @public
export function useRelatedEntities(
  entity: Entity,
  relationFilter: {
    type?: string;
    kind?: string;
  },
): {
  entities: Entity[] | undefined;
  loading: boolean;
  error: Error | undefined;
};

// @public @deprecated
export class UserListFilter implements EntityFilter {
  constructor(
    value: UserListFilterKind,
    isOwnedEntity: (entity: Entity) => boolean,
    isStarredEntity: (entity: Entity) => boolean,
  );
  // (undocumented)
  filterEntity(entity: Entity): boolean;
  // (undocumented)
  readonly isOwnedEntity: (entity: Entity) => boolean;
  // (undocumented)
  readonly isStarredEntity: (entity: Entity) => boolean;
  // (undocumented)
  toQueryValue(): string;
  // (undocumented)
  readonly value: UserListFilterKind;
}

// @public (undocumented)
export type UserListFilterKind = 'owned' | 'starred' | 'all';

// @public (undocumented)
export const UserListPicker: (
  props: UserListPickerProps,
) => React_2.JSX.Element | null;

// @public (undocumented)
export type UserListPickerProps = {
  initialFilter?: UserListFilterKind;
  availableFilters?: UserListFilterKind[];
  hidden?: boolean;
  alwaysKeepFilters?: boolean;
};

// @public (undocumented)
export function useStarredEntities(): {
  starredEntities: Set<string>;
  toggleStarredEntity: (
    entityOrRef: Entity | CompoundEntityRef | string,
  ) => void;
  isStarredEntity: (
    entityOrRef: Entity | CompoundEntityRef | string,
  ) => boolean;
};

// @public (undocumented)
export function useStarredEntity(
  entityOrRef: Entity | CompoundEntityRef | string,
): {
  toggleStarredEntity: () => void;
  isStarredEntity: boolean;
};