tinybase 9.1.0-beta.0 → 9.1.0-beta.2

package/@types/ui-solid/with-schemas/index.d.ts

@@ -84,6 +84,7 @@ import type {
   IdOrNull,
   Ids,
   ParameterizedCallback,
+  Sorter,
 } from '../../common/with-schemas/index.d.ts';
 import type {
   Indexes,
@@ -142,6 +143,8 @@ import type {
   MapCell,
   MapValue,
   OptionalSchemas,
+  PartialRow,
+  PartialValues,
   Row,
   RowCountListener,
   RowIdsListener,
@@ -1635,6 +1638,7 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
  *   descending?: MaybeAccessor<boolean | undefined>,
  *   offset?: MaybeAccessor<number | undefined>,
  *   limit?: MaybeAccessor<number | undefined>,
+ *   sorter?: Sorter,
  *   storeOrStoreId?: MaybeAccessor<StoreOrStoreId | undefined>,
  * ): Accessor<Ids>;
  * ```
@@ -1654,6 +1658,8 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
  * @param descending Whether the sorting should be in descending order.
  * @param offset The number of Row Ids to skip for pagination purposes, if any.
  * @param limit The maximum number of Row Ids to return, or `undefined` for all.
+ * @param sorter A custom function for comparing the sorting values, or
+ * `undefined` to use the default alphanumeric sorting.
  * @param storeOrStoreId The Store to be accessed: omit for the default context
  * Store, provide an Id for a named context Store, or provide an explicit
  * reference.
@@ -1677,6 +1683,7 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
  *     false,
  *     0,
  *     undefined,
+ *     undefined,
  *     store,
  *   );
  *   console.log(JSON.stringify(rowIds()));
@@ -1697,6 +1704,7 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
       descending?: MaybeAccessor<boolean | undefined>,
       offset?: MaybeAccessor<number | undefined>,
       limit?: MaybeAccessor<number | undefined>,
+      sorter?: Sorter,
       storeOrStoreId?: MaybeAccessor<StoreOrStoreId<Schemas> | undefined>,
     ): Accessor<Ids>;
 
@@ -1704,7 +1712,8 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
  * When called with an object as the first argument, the useSortedRowIds method
  * destructures it to make it easier to skip optional parameters.
  * @param args A SortedRowIdsArgs object containing the Id of the Table in the
- * Store, and optional `cellId`, `descending`, `offset`, and `limit` parameters.
+ * Store, and optional `cellId`, `descending`, `offset`, `limit`, and `sorter`
+ * parameters.
  * @param storeOrStoreId The Store to be accessed: omit for the default context
  * Store, provide an Id for a named context Store, or provide an explicit
  * reference.
@@ -2684,13 +2693,13 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
  * @category Store primitives
  * @since v8.3.0
  */
-  useSetTablesCallback: <Parameter, SetTables = Tables<Schemas[0], true>>(
+  useSetTablesCallback: <Parameter>(
     getTables: (
       parameter: Parameter,
       store: Store<Schemas>,
-    ) => NoInfer<SetTables>,
+    ) => Tables<Schemas[0], true>,
     storeOrStoreId?: MaybeAccessor<StoreOrStoreId<Schemas> | undefined>,
-    then?: (store: Store<Schemas>, tables: SetTables) => void,
+    then?: (store: Store<Schemas>, tables: Tables<Schemas[0], true>) => void,
   ) => ParameterizedCallback<Parameter>;
 
   /**
@@ -2796,15 +2805,17 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
   useSetTableCallback: <
     Parameter,
     TableId extends TableIdFromSchema<Schemas[0]>,
-    SetTable = Table<Schemas[0], TableId, true>,
   >(
     tableId: MaybeAccessor<TableId> | GetId<Schemas, Parameter, TableId>,
     getTable: (
       parameter: Parameter,
       store: Store<Schemas>,
-    ) => NoInfer<SetTable>,
+    ) => Table<Schemas[0], TableId, true>,
     storeOrStoreId?: MaybeAccessor<StoreOrStoreId<Schemas> | undefined>,
-    then?: (store: Store<Schemas>, table: SetTable) => void,
+    then?: (
+      store: Store<Schemas>,
+      table: Table<Schemas[0], TableId, true>,
+    ) => void,
   ) => ParameterizedCallback<Parameter>;
 
   /**
@@ -2910,16 +2921,15 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
  * @category Store primitives
  * @since v8.3.0
  */
-  useSetRowCallback: <
-    Parameter,
-    TableId extends TableIdFromSchema<Schemas[0]>,
-    SetRow = Row<Schemas[0], TableId, true>,
-  >(
+  useSetRowCallback: <Parameter, TableId extends TableIdFromSchema<Schemas[0]>>(
     tableId: MaybeAccessor<TableId> | GetId<Schemas, Parameter, TableId>,
     rowId: MaybeAccessor<Id> | GetId<Schemas, Parameter, Id>,
-    getRow: (parameter: Parameter, store: Store<Schemas>) => NoInfer<SetRow>,
+    getRow: (
+      parameter: Parameter,
+      store: Store<Schemas>,
+    ) => Row<Schemas[0], TableId, true>,
     storeOrStoreId?: MaybeAccessor<StoreOrStoreId<Schemas> | undefined>,
-    then?: (store: Store<Schemas>, row: SetRow) => void,
+    then?: (store: Store<Schemas>, row: Row<Schemas[0], TableId, true>) => void,
   ) => ParameterizedCallback<Parameter>;
 
   /**
@@ -3032,15 +3042,18 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
  * @category Store primitives
  * @since v8.3.0
  */
-  useAddRowCallback: <
-    Parameter,
-    TableId extends TableIdFromSchema<Schemas[0]>,
-    AddRow = Row<Schemas[0], TableId, true>,
-  >(
+  useAddRowCallback: <Parameter, TableId extends TableIdFromSchema<Schemas[0]>>(
     tableId: MaybeAccessor<TableId> | GetId<Schemas, Parameter, TableId>,
-    getRow: (parameter: Parameter, store: Store<Schemas>) => NoInfer<AddRow>,
+    getRow: (
+      parameter: Parameter,
+      store: Store<Schemas>,
+    ) => Row<Schemas[0], TableId, true>,
     storeOrStoreId?: MaybeAccessor<StoreOrStoreId<Schemas> | undefined>,
-    then?: (rowId: Id | undefined, store: Store<Schemas>, row: AddRow) => void,
+    then?: (
+      rowId: Id | undefined,
+      store: Store<Schemas>,
+      row: Row<Schemas[0], TableId, true>,
+    ) => void,
     reuseRowIds?: boolean,
   ) => ParameterizedCallback<Parameter>;
 
@@ -3151,16 +3164,18 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
   useSetPartialRowCallback: <
     Parameter,
     TableId extends TableIdFromSchema<Schemas[0]>,
-    SetPartialRow = Row<Schemas[0], TableId, true>,
   >(
     tableId: MaybeAccessor<TableId> | GetId<Schemas, Parameter, TableId>,
     rowId: MaybeAccessor<Id> | GetId<Schemas, Parameter, Id>,
     getPartialRow: (
       parameter: Parameter,
       store: Store<Schemas>,
-    ) => NoInfer<SetPartialRow>,
+    ) => PartialRow<Schemas[0], TableId>,
     storeOrStoreId?: MaybeAccessor<StoreOrStoreId<Schemas> | undefined>,
-    then?: (store: Store<Schemas>, partialRow: SetPartialRow) => void,
+    then?: (
+      store: Store<Schemas>,
+      partialRow: PartialRow<Schemas[0], TableId>,
+    ) => void,
   ) => ParameterizedCallback<Parameter>;
 
   /**
@@ -3346,13 +3361,13 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
  * @category Store primitives
  * @since v8.3.0
  */
-  useSetValuesCallback: <Parameter, SetValues = Values<Schemas[1], true>>(
+  useSetValuesCallback: <Parameter>(
     getValues: (
       parameter: Parameter,
       store: Store<Schemas>,
-    ) => NoInfer<SetValues>,
+    ) => Values<Schemas[1], true>,
     storeOrStoreId?: MaybeAccessor<StoreOrStoreId<Schemas> | undefined>,
-    then?: (store: Store<Schemas>, values: SetValues) => void,
+    then?: (store: Store<Schemas>, values: Values<Schemas[1], true>) => void,
   ) => ParameterizedCallback<Parameter>;
 
   /**
@@ -3453,16 +3468,16 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
  * @category Store primitives
  * @since v8.3.0
  */
-  useSetPartialValuesCallback: <
-    Parameter,
-    SetPartialValues = Values<Schemas[1], true>,
-  >(
+  useSetPartialValuesCallback: <Parameter>(
     getPartialValues: (
       parameter: Parameter,
       store: Store<Schemas>,
-    ) => NoInfer<SetPartialValues>,
+    ) => PartialValues<Schemas[1]>,
     storeOrStoreId?: MaybeAccessor<StoreOrStoreId<Schemas> | undefined>,
-    then?: (store: Store<Schemas>, partialValues: SetPartialValues) => void,
+    then?: (
+      store: Store<Schemas>,
+      partialValues: PartialValues<Schemas[1]>,
+    ) => void,
   ) => ParameterizedCallback<Parameter>;
 
   /**
@@ -5274,7 +5289,8 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
  * When called with an object as the first argument, the useSortedRowIds method
  * destructures it to make it easier to skip optional parameters.
  * @param args A SortedRowIdsArgs object containing the Id of the Table in the
- * Store, and optional `cellId`, `descending`, `offset`, and `limit` parameters.
+ * Store, and optional `cellId`, `descending`, `offset`, `limit`, and `sorter`
+ * parameters.
  * @param listener The function that will be called whenever the sorted Row Ids
  * in the Table change.
  * @param mutator An optional boolean that indicates that the listener mutates
@@ -7819,6 +7835,35 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
     indexesOrIndexesId?: MaybeAccessor<IndexesOrIndexesId<Schemas> | undefined>,
   ): Accessor<Ids>;
 
+  /**
+ * The useHasIndex primitive returns a boolean indicating whether a given Index
+ * exists in the Indexes object, and registers a listener so that any changes to
+ * that result will cause an update.
+ *
+ * This has schema-based typing. The following is a simplified representation:
+ *
+ * ```ts override
+ * useHasIndex(
+ *   indexId: MaybeAccessor<Id>,
+ *   indexesOrIndexesId?: MaybeAccessor<IndexesOrIndexesId | undefined>,
+ * ): Accessor<boolean>;
+ * ```
+ *
+ * This primitive follows the same Indexes object resolution rules as the
+ * useIndexIds primitive.
+ * @param indexId The Id of a possible Index in the Indexes object.
+ * @param indexesOrIndexesId The Indexes object to be accessed: omit for the
+ * default context Indexes object, provide an Id for a named context Indexes
+ * object, or provide an explicit reference.
+ * @returns Whether an Index with that Id exists.
+ * @category Indexes primitives
+ * @since v9.1.0
+ */
+  useHasIndex: (
+    indexId: MaybeAccessor<Id>,
+    indexesOrIndexesId?: MaybeAccessor<IndexesOrIndexesId<Schemas> | undefined>,
+  ) => Accessor<boolean>;
+
   /**
  * The useSliceIds primitive gets the list of Slice Ids in an Index, and
  * registers a listener so that any changes to that result will cause an update.
@@ -7915,6 +7960,38 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
     indexesOrIndexesId?: MaybeAccessor<IndexesOrIndexesId<Schemas> | undefined>,
   ) => Accessor<Ids>;
 
+  /**
+ * The useHasSlice primitive returns a boolean indicating whether a given Slice
+ * exists in an Index, and registers a listener so that any changes to that
+ * result will cause an update.
+ *
+ * This has schema-based typing. The following is a simplified representation:
+ *
+ * ```ts override
+ * useHasSlice(
+ *   indexId: MaybeAccessor<Id>,
+ *   sliceId: MaybeAccessor<Id>,
+ *   indexesOrIndexesId?: MaybeAccessor<IndexesOrIndexesId | undefined>,
+ * ): Accessor<boolean>;
+ * ```
+ *
+ * This primitive follows the same Indexes object resolution rules as the
+ * useSliceIds primitive.
+ * @param indexId The Id of a possible Index in the Indexes object.
+ * @param sliceId The Id of a possible Slice in the Index.
+ * @param indexesOrIndexesId The Indexes object to be accessed: omit for the
+ * default context Indexes object, provide an Id for a named context Indexes
+ * object, or provide an explicit reference.
+ * @returns Whether a Slice with that Id exists.
+ * @category Indexes primitives
+ * @since v9.1.0
+ */
+  useHasSlice: (
+    indexId: MaybeAccessor<Id>,
+    sliceId: MaybeAccessor<Id>,
+    indexesOrIndexesId?: MaybeAccessor<IndexesOrIndexesId<Schemas> | undefined>,
+  ) => Accessor<boolean>;
+
   /**
  * The useSliceRowIds primitive gets the list of Row Ids in a given Slice, and
  * registers a listener so that any changes to that result will cause an update.

package/@types/ui-svelte/index.d.ts

@@ -35,7 +35,7 @@ import type {
   CheckpointListener,
   Checkpoints,
 } from '../checkpoints/index.d.ts';
-import type {Id, IdOrNull, Ids} from '../common/index.d.ts';
+import type {Id, IdOrNull, Ids, Sorter} from '../common/index.d.ts';
 import type {
   Indexes,
   SliceIdsListener,
@@ -82,6 +82,7 @@ import type {
   RowCountListener,
   RowIdsListener,
   RowListener,
+  SortedRowIdsArgs,
   SortedRowIdsListener,
   Store,
   Table,
@@ -2893,6 +2894,8 @@ export function getRowIds(
  * @param descending Whether to sort descending (or a getter returning it).
  * @param offset The starting Row offset (or a getter returning it).
  * @param limit The maximum number of Rows to return (or a getter returning it).
+ * @param sorter A custom function for comparing the sorting values, or
+ * `undefined` to use the default alphanumeric sorting.
  * @param storeOrStoreId The Store to use (plain value or getter), or its Id.
  * @returns A reactive object with a `current` Ids property.
  * @example
@@ -2907,7 +2910,15 @@ export function getRowIds(
  *
  *   let {store} = $props();
  *
- *   const result = getSortedRowIds('pets', 'sold', false, 0, undefined, store);
+ *   const result = getSortedRowIds(
+ *     'pets',
+ *     'sold',
+ *     false,
+ *     0,
+ *     undefined,
+ *     undefined,
+ *     store,
+ *   );
  * </script>
  *
  * {JSON.stringify(result.current)}
@@ -2941,6 +2952,23 @@ export function getSortedRowIds(
   descending?: MaybeGetter<boolean>,
   offset?: MaybeGetter<number>,
   limit?: MaybeGetter<number | undefined>,
+  sorter?: Sorter,
+  storeOrStoreId?: MaybeGetter<StoreOrStoreId | undefined>,
+): {readonly current: Ids};
+
+/**
+ * When called with an object as the first argument, the getSortedRowIds
+ * function destructures it to make it easier to skip optional parameters.
+ * @param args A SortedRowIdsArgs object containing the Id of the Table in the
+ * Store, and optional `cellId`, `descending`, `offset`, `limit`, and `sorter`
+ * parameters.
+ * @param storeOrStoreId The Store to use (plain value or getter), or its Id.
+ * @returns A reactive object with a `current` Ids property.
+ * @category Getter
+ * @since v9.1.0
+ */
+export function getSortedRowIds(
+  args: SortedRowIdsArgs,
   storeOrStoreId?: MaybeGetter<StoreOrStoreId | undefined>,
 ): {readonly current: Ids};
 
@@ -4209,6 +4237,22 @@ export function getIndexIds(
   readonly current: Ids;
 };
 
+/**
+ * The hasIndex function returns a reactive object reflecting whether a given
+ * Index exists in the Indexes object, and registers a listener so that any
+ * changes will update `current`.
+ * @param indexId The Id of the possible Index (or a getter returning it).
+ * @param indexesOrIndexesId The Indexes object to use (plain or getter), or its
+ * Id.
+ * @returns A reactive object with a `current` boolean property.
+ * @category Getter
+ * @since v9.1.0
+ */
+export function hasIndex(
+  indexId: MaybeGetter<Id>,
+  indexesOrIndexesId?: MaybeGetter<IndexesOrIndexesId | undefined>,
+): {readonly current: boolean};
+
 /**
  * The getSliceIds function returns a reactive object reflecting the Ids of the
  * Slices in an Index, and registers a listener so that any changes will update
@@ -4267,6 +4311,24 @@ export function getSliceIds(
   indexesOrIndexesId?: MaybeGetter<IndexesOrIndexesId | undefined>,
 ): {readonly current: Ids};
 
+/**
+ * The hasSlice function returns a reactive object reflecting whether a given
+ * Slice exists in an Index, and registers a listener so that any changes will
+ * update `current`.
+ * @param indexId The Id of the Index (or a getter returning it).
+ * @param sliceId The Id of the possible Slice (or a getter returning it).
+ * @param indexesOrIndexesId The Indexes object to use (plain or getter), or its
+ * Id.
+ * @returns A reactive object with a `current` boolean property.
+ * @category Getter
+ * @since v9.1.0
+ */
+export function hasSlice(
+  indexId: MaybeGetter<Id>,
+  sliceId: MaybeGetter<Id>,
+  indexesOrIndexesId?: MaybeGetter<IndexesOrIndexesId | undefined>,
+): {readonly current: boolean};
+
 /**
  * The getSliceRowIds function returns a reactive object reflecting the Ids of
  * the Rows in a Slice, and registers a listener so that any changes will update
@@ -6936,6 +6998,26 @@ export function onSortedRowIds(
   storeOrStoreId?: MaybeGetter<StoreOrStoreId | undefined>,
 ): void;
 
+/**
+ * When called with an object as the first argument, the onSortedRowIds function
+ * destructures it to make it easier to skip optional parameters.
+ * @param args A SortedRowIdsArgs object containing the Id of the Table in the
+ * Store, and optional `cellId`, `descending`, `offset`, `limit`, and `sorter`
+ * parameters.
+ * @param listener The function to call when sorted Row Ids change.
+ * @param mutator An optional boolean indicating the listener mutates Store
+ * data.
+ * @param storeOrStoreId The Store to use, or its Id.
+ * @category Listener
+ * @since v9.1.0
+ */
+export function onSortedRowIds(
+  args: SortedRowIdsArgs,
+  listener: SortedRowIdsListener,
+  mutator?: boolean,
+  storeOrStoreId?: MaybeGetter<StoreOrStoreId | undefined>,
+): void;
+
 /**
  * The onHasRow function registers a listener that is called whenever a
  * specified Row is added to or removed from a Table.

package/@types/ui-svelte/with-schemas/index.d.ts

@@ -23,7 +23,12 @@ import type {
   CheckpointListener,
   Checkpoints,
 } from '../../checkpoints/with-schemas/index.d.ts';
-import type {Id, IdOrNull, Ids} from '../../common/with-schemas/index.d.ts';
+import type {
+  Id,
+  IdOrNull,
+  Ids,
+  Sorter,
+} from '../../common/with-schemas/index.d.ts';
 import type {
   Indexes,
   SliceIdsListener,
@@ -77,6 +82,7 @@ import type {
   RowCountListener,
   RowIdsListener,
   RowListener,
+  SortedRowIdsArgs,
   SortedRowIdsListener,
   Store,
   Table,
@@ -3151,7 +3157,8 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
     storeOrStoreId?: StoreOrStoreId<Schemas>,
   ) => {readonly current: Ids};
 
-  /**
+  getSortedRowIds: {
+    /**
  * The getSortedRowIds function returns a reactive object reflecting the sorted
  * Row Ids in a Table, and registers a listener so that any changes will update
  * `current`.
@@ -3160,6 +3167,8 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
  * @param descending Whether to sort descending (or a getter returning it).
  * @param offset The starting Row offset (or a getter returning it).
  * @param limit The maximum number of Rows to return (or a getter returning it).
+ * @param sorter A custom function for comparing the sorting values, or
+ * `undefined` to use the default alphanumeric sorting.
  * @param storeOrStoreId The Store to use (plain value or getter), or its Id.
  * @returns A reactive object with a `current` Ids property.
  * @example
@@ -3175,6 +3184,7 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
  *   descending?: MaybeGetter<boolean>,
  *   offset?: MaybeGetter<number>,
  *   limit?: MaybeGetter<number | undefined>,
+ *   sorter?: Sorter,
  *   storeOrStoreId?: MaybeGetter<StoreOrStoreId | undefined>,
  * ): {readonly current: Ids};
  * ```
@@ -3187,7 +3197,15 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
  *
  *   let {store} = $props();
  *
- *   const result = getSortedRowIds('pets', 'sold', false, 0, undefined, store);
+ *   const result = getSortedRowIds(
+ *     'pets',
+ *     'sold',
+ *     false,
+ *     0,
+ *     undefined,
+ *     undefined,
+ *     store,
+ *   );
  * </script>
  *
  * {JSON.stringify(result.current)}
@@ -3215,14 +3233,32 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
  * @category Getter
  * @since v8.1.0
  */
-  getSortedRowIds: <TableId extends TableIdFromSchema<Schemas[0]>>(
-    tableId: MaybeGetter<TableId>,
-    cellId?: MaybeGetter<CellIdFromSchema<Schemas[0], TableId> | undefined>,
-    descending?: MaybeGetter<boolean>,
-    offset?: MaybeGetter<number>,
-    limit?: MaybeGetter<number | undefined>,
-    storeOrStoreId?: StoreOrStoreId<Schemas>,
-  ) => {readonly current: Ids};
+    <TableId extends TableIdFromSchema<Schemas[0]>>(
+      tableId: MaybeGetter<TableId>,
+      cellId?: MaybeGetter<CellIdFromSchema<Schemas[0], TableId> | undefined>,
+      descending?: MaybeGetter<boolean>,
+      offset?: MaybeGetter<number>,
+      limit?: MaybeGetter<number | undefined>,
+      sorter?: Sorter,
+      storeOrStoreId?: StoreOrStoreId<Schemas>,
+    ): {readonly current: Ids};
+
+    /**
+ * When called with an object as the first argument, the getSortedRowIds
+ * function destructures it to make it easier to skip optional parameters.
+ * @param args A SortedRowIdsArgs object containing the Id of the Table in the
+ * Store, and optional `cellId`, `descending`, `offset`, `limit`, and `sorter`
+ * parameters.
+ * @param storeOrStoreId The Store to use (plain value or getter), or its Id.
+ * @returns A reactive object with a `current` Ids property.
+ * @category Getter
+ * @since v9.1.0
+ */
+    <TableId extends TableIdFromSchema<Schemas[0]>>(
+      args: SortedRowIdsArgs<Schemas[0], TableId>,
+      storeOrStoreId?: StoreOrStoreId<Schemas>,
+    ): {readonly current: Ids};
+  };
 
   /**
  * The hasRow function returns a reactive object indicating whether a Row exists
@@ -4682,6 +4718,22 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
     readonly current: Ids;
   };
 
+  /**
+ * The hasIndex function returns a reactive object reflecting whether a given
+ * Index exists in the Indexes object, and registers a listener so that any
+ * changes will update `current`.
+ * @param indexId The Id of the possible Index (or a getter returning it).
+ * @param indexesOrIndexesId The Indexes object to use (plain or getter), or its
+ * Id.
+ * @returns A reactive object with a `current` boolean property.
+ * @category Getter
+ * @since v9.1.0
+ */
+  hasIndex: (
+    indexId: MaybeGetter<Id>,
+    indexesOrIndexesId?: MaybeGetter<IndexesOrIndexesId<Schemas> | undefined>,
+  ) => {readonly current: boolean};
+
   /**
  * The getSliceIds function returns a reactive object reflecting the Ids of the
  * Slices in an Index, and registers a listener so that any changes will update
@@ -4749,6 +4801,24 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
     indexesOrIndexesId?: IndexesOrIndexesId<Schemas>,
   ) => {readonly current: Ids};
 
+  /**
+ * The hasSlice function returns a reactive object reflecting whether a given
+ * Slice exists in an Index, and registers a listener so that any changes will
+ * update `current`.
+ * @param indexId The Id of the Index (or a getter returning it).
+ * @param sliceId The Id of the possible Slice (or a getter returning it).
+ * @param indexesOrIndexesId The Indexes object to use (plain or getter), or its
+ * Id.
+ * @returns A reactive object with a `current` boolean property.
+ * @category Getter
+ * @since v9.1.0
+ */
+  hasSlice: (
+    indexId: MaybeGetter<Id>,
+    sliceId: MaybeGetter<Id>,
+    indexesOrIndexesId?: IndexesOrIndexesId<Schemas>,
+  ) => {readonly current: boolean};
+
   /**
  * The getSliceRowIds function returns a reactive object reflecting the Ids of
  * the Rows in a Slice, and registers a listener so that any changes will update
@@ -7745,7 +7815,8 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
     storeOrStoreId?: StoreOrStoreId<Schemas>,
   ) => void;
 
-  /**
+  onSortedRowIds: {
+    /**
  * The onSortedRowIds function registers a listener that is called whenever the
  * sorted Row Ids in a Table change.
  * @param tableId The Id of the Table to listen to.
@@ -7818,19 +7889,45 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
  * @category Listener
  * @since v8.1.0
  */
-  onSortedRowIds: <
-    TableId extends TableIdFromSchema<Schemas[0]>,
-    CellIdOrUndefined extends CellIdFromSchema<Schemas[0], TableId> | undefined,
-  >(
-    tableId: MaybeGetter<TableId>,
-    cellId: MaybeGetter<CellIdOrUndefined>,
-    descending: MaybeGetter<boolean>,
-    offset: MaybeGetter<number>,
-    limit: MaybeGetter<number | undefined>,
-    listener: SortedRowIdsListener<Schemas, TableId, CellIdOrUndefined>,
-    mutator?: boolean,
-    storeOrStoreId?: StoreOrStoreId<Schemas>,
-  ) => void;
+    <
+      TableId extends TableIdFromSchema<Schemas[0]>,
+      CellIdOrUndefined extends
+        CellIdFromSchema<Schemas[0], TableId> | undefined,
+    >(
+      tableId: MaybeGetter<TableId>,
+      cellId: MaybeGetter<CellIdOrUndefined>,
+      descending: MaybeGetter<boolean>,
+      offset: MaybeGetter<number>,
+      limit: MaybeGetter<number | undefined>,
+      listener: SortedRowIdsListener<Schemas, TableId, CellIdOrUndefined>,
+      mutator?: boolean,
+      storeOrStoreId?: StoreOrStoreId<Schemas>,
+    ): void;
+
+    /**
+ * When called with an object as the first argument, the onSortedRowIds function
+ * destructures it to make it easier to skip optional parameters.
+ * @param args A SortedRowIdsArgs object containing the Id of the Table in the
+ * Store, and optional `cellId`, `descending`, `offset`, `limit`, and `sorter`
+ * parameters.
+ * @param listener The function to call when sorted Row Ids change.
+ * @param mutator An optional boolean indicating the listener mutates Store
+ * data.
+ * @param storeOrStoreId The Store to use, or its Id.
+ * @category Listener
+ * @since v9.1.0
+ */
+    <
+      TableId extends TableIdFromSchema<Schemas[0]>,
+      CellIdOrUndefined extends
+        CellIdFromSchema<Schemas[0], TableId> | undefined,
+    >(
+      args: SortedRowIdsArgs<Schemas[0], TableId, CellIdOrUndefined>,
+      listener: SortedRowIdsListener<Schemas, TableId, CellIdOrUndefined>,
+      mutator?: boolean,
+      storeOrStoreId?: StoreOrStoreId<Schemas>,
+    ): void;
+  };
 
   /**
  * The onHasRow function registers a listener that is called whenever a