fix: Missing or incorrect type exports

src/Cloud.ts

@@ -4,7 +4,9 @@ import encode from './encode';
 import ParseError from './ParseError';
 import ParseQuery from './ParseQuery';
 import ParseObject from './ParseObject';
-import type { RequestOptions } from './RESTController';
+import type { RequestOptions, BaseRequestOptions } from './RESTController';
+
+export type RunOptions = BaseRequestOptions;
 
 /**
  * Contains functions for calling and declaring
@@ -40,12 +42,12 @@ import type { RequestOptions } from './RESTController';
 export function run<T extends () => any>(
   name: string,
   data?: null,
-  options?: RequestOptions
+  options?: RunOptions
 ): Promise<ReturnType<T>>;
 export function run<
   T extends (param: { [P in keyof Parameters<T>[0]]: Parameters<T>[0][P] }) => any,
->(name: string, data: Parameters<T>[0], options?: RequestOptions): Promise<ReturnType<T>>;
-export function run(name: string, data?: any, options?: RequestOptions): Promise<any> {
+>(name: string, data: Parameters<T>[0], options?: RunOptions): Promise<ReturnType<T>>;
+export function run(name: string, data?: any, options?: RunOptions): Promise<any> {
   if (typeof name !== 'string' || name.length === 0) {
     throw new TypeError('Cloud function name must be a string.');
   }

src/ParseObject.ts

@@ -28,7 +28,7 @@ import * as UniqueInstanceStateController from './UniqueInstanceStateController'
 import unsavedChildren from './unsavedChildren';
 
 import type { AttributeMap, OpsMap } from './ObjectStateMutations';
-import type { RequestOptions, FullOptions } from './RESTController';
+import type { RequestOptions, FullOptions, BaseRequestOptions } from './RESTController';
 import type ParseGeoPoint from './ParseGeoPoint';
 import type ParsePolygon from './ParsePolygon';
 
@@ -45,35 +45,63 @@ interface SaveParams {
   body: AttributeMap;
 }
 
-export type SaveOptions = FullOptions & {
+export interface SaveOptions extends BaseRequestOptions {
+  /** If `false`, nested objects will not be saved (default is `true`). */
   cascadeSave?: boolean;
-  context?: AttributeMap;
   batchSize?: number;
   transaction?: boolean;
-};
+}
 
-interface FetchOptions {
-  useMasterKey?: boolean;
-  sessionToken?: string;
+export interface FetchOptions extends BaseRequestOptions {
   include?: string | string[];
-  context?: AttributeMap;
 }
 
 export interface SetOptions {
   ignoreValidation?: boolean;
   unset?: boolean;
 }
 
+export type DestroyOptions = BaseRequestOptions;
+
+/** Options for destroyAll batch operation */
+export interface DestroyAllOptions extends BaseRequestOptions {
+  /** batchSize: How many objects to yield in each batch (default: 20) */
+  batchSize?: number;
+  /** Set to true to enable transactions */
+  transaction?: boolean;
+}
+
+/** Options for saveAll batch operation */
+export interface SaveAllOptions extends BaseRequestOptions {
+  /** batchSize: How many objects to yield in each batch (default: 20) */
+  batchSize?: number;
+  /** If `false`, nested objects will not be saved (default is `true`). */
+  cascadeSave?: boolean;
+  /** Set to true to enable transactions */
+  transaction?: boolean;
+}
+
+/** Options for fetchAll batch operation */
+export interface FetchAllOptions extends BaseRequestOptions {
+  include?: string | string[];
+}
+
 export type AttributeKey<T> = Extract<keyof T, string>;
 
 export type Attributes = Record<string, any>;
 
-interface JSONBaseAttributes {
+export interface JSONBaseAttributes {
   objectId: string;
   createdAt: string;
   updatedAt: string;
 }
 
+export interface BaseAttributes {
+  objectId: string;
+  createdAt: Date;
+  updatedAt: Date;
+}
+
 interface CommonAttributes {
   ACL: ParseACL;
 }
@@ -82,7 +110,7 @@ type AtomicKey<T> = {
   [K in keyof T]: NonNullable<T[K]> extends any[] ? K : never;
 };
 
-type Encode<T> = T extends ParseObject
+export type Encode<T> = T extends ParseObject
   ? ReturnType<T['toJSON']> | Pointer
   : T extends ParseACL | ParseGeoPoint | ParsePolygon | ParseRelation | ParseFile
     ? ReturnType<T['toJSON']>
@@ -96,7 +124,7 @@ type Encode<T> = T extends ParseObject
             ? ToJSON<T>
             : T;
 
-type ToJSON<T> = {
+export type ToJSON<T> = {
   [K in keyof T]: Encode<T[K]>;
 };
 
@@ -1481,7 +1509,7 @@ class ParseObject<T extends Attributes = Attributes> {
    * @returns {Promise} A promise that is fulfilled when the destroy
    *     completes.
    */
-  destroy(options?: RequestOptions): Promise<ParseObject | undefined> {
+  destroy(options?: DestroyOptions): Promise<ParseObject | undefined> {
     if (!this.id) {
       return Promise.resolve(undefined);
     }
@@ -1637,7 +1665,7 @@ class ParseObject<T extends Attributes = Attributes> {
    * @static
    * @returns {Parse.Object[]}
    */
-  static fetchAll<T extends ParseObject>(list: T[], options?: RequestOptions): Promise<T[]> {
+  static fetchAll<T extends ParseObject>(list: T[], options?: FetchAllOptions): Promise<T[]> {
     const fetchOptions = ParseObject._getRequestOptions(options);
     return CoreManager.getObjectController().fetch(list, true, fetchOptions) as Promise<T[]>;
   }
@@ -1748,7 +1776,10 @@ class ParseObject<T extends Attributes = Attributes> {
    * @static
    * @returns {Parse.Object[]}
    */
-  static fetchAllIfNeeded<T extends ParseObject>(list: T[], options?: FetchOptions): Promise<T[]> {
+  static fetchAllIfNeeded<T extends ParseObject>(
+    list: T[],
+    options?: FetchAllOptions
+  ): Promise<T[]> {
     const fetchOptions = ParseObject._getRequestOptions(options);
     return CoreManager.getObjectController().fetch(list, false, fetchOptions) as Promise<T[]>;
   }
@@ -1824,9 +1855,9 @@ class ParseObject<T extends Attributes = Attributes> {
    * @returns {Promise} A promise that is fulfilled when the destroyAll
    * completes.
    */
-  static destroyAll(list: ParseObject[], options?: SaveOptions) {
+  static destroyAll<T extends ParseObject>(list: T[], options?: DestroyAllOptions): Promise<T[]> {
     const destroyOptions = ParseObject._getRequestOptions(options);
-    return CoreManager.getObjectController().destroy(list, destroyOptions);
+    return CoreManager.getObjectController().destroy(list, destroyOptions) as Promise<T[]>;
   }
 
   /**
@@ -1858,7 +1889,7 @@ class ParseObject<T extends Attributes = Attributes> {
    * @static
    * @returns {Parse.Object[]}
    */
-  static saveAll<T extends ParseObject[]>(list: T, options?: SaveOptions): Promise<T> {
+  static saveAll<T extends ParseObject[]>(list: T, options?: SaveAllOptions): Promise<T> {
     const saveOptions = ParseObject._getRequestOptions(options);
     return CoreManager.getObjectController().save(list, saveOptions) as any;
   }
@@ -2657,4 +2688,41 @@ const DefaultController = {
 CoreManager.setParseObject(ParseObject);
 CoreManager.setObjectController(DefaultController);
 
+export interface ObjectStatic<T extends ParseObject = ParseObject> {
+  new (...args: any[]): T;
+  createWithoutData(id: string): T;
+  destroyAll<U extends ParseObject>(list: U[], options?: DestroyAllOptions): Promise<U[]>;
+  extend(className: string | { className: string }, protoProps?: any, classProps?: any): any;
+  fetchAll<U extends ParseObject>(list: U[], options?: FetchAllOptions): Promise<U[]>;
+  fetchAllIfNeeded<U extends ParseObject>(list: U[], options?: FetchAllOptions): Promise<U[]>;
+  fetchAllIfNeededWithInclude<U extends ParseObject>(
+    list: U[],
+    keys: keyof U['attributes'] | (keyof U['attributes'])[],
+    options?: RequestOptions
+  ): Promise<U[]>;
+  fetchAllWithInclude<U extends ParseObject>(
+    list: U[],
+    keys: keyof U['attributes'] | (keyof U['attributes'])[],
+    options?: RequestOptions
+  ): Promise<U[]>;
+  fromJSON(json: any, override?: boolean, dirty?: boolean): T;
+  pinAll(objects: ParseObject[]): Promise<void>;
+  pinAllWithName(name: string, objects: ParseObject[]): Promise<void>;
+  registerSubclass(className: string, clazz: new (options?: any) => T): void;
+  saveAll<U extends ParseObject[]>(list: U, options?: SaveAllOptions): Promise<U>;
+  unPinAll(objects: ParseObject[]): Promise<void>;
+  unPinAllObjects(): Promise<void>;
+  unPinAllObjectsWithName(name: string): Promise<void>;
+  unPinAllWithName(name: string, objects: ParseObject[]): Promise<void>;
+}
+
+export interface ObjectConstructor extends ObjectStatic {
+  new <T extends Attributes>(className: string, attributes: T, options?: any): ParseObject<T>;
+  new (
+    className?: string | { className: string; [attr: string]: any },
+    attributes?: Attributes,
+    options?: any
+  ): ParseObject;
+}
+
 export default ParseObject;

src/ParseQuery.ts

@@ -8,28 +8,30 @@ import OfflineQuery from './OfflineQuery';
 import { DEFAULT_PIN } from './LocalDatastoreUtils';
 
 import type LiveQuerySubscription from './LiveQuerySubscription';
-import type { RequestOptions, FullOptions } from './RESTController';
-import type { Pointer } from './ParseObject';
+import type { RequestOptions, BaseRequestOptions } from './RESTController';
+import type { Pointer, BaseAttributes } from './ParseObject';
 
-type BatchOptions = FullOptions & {
+export interface BatchOptions extends BaseRequestOptions {
   batchSize?: number;
-  useMasterKey?: boolean;
-  useMaintenanceKey?: boolean;
-  sessionToken?: string;
-  context?: Record<string, any>;
   json?: boolean;
-};
+}
 
 export type WhereClause = Record<string, any>;
 
-interface QueryOptions {
-  useMasterKey?: boolean;
-  sessionToken?: string;
-  context?: Record<string, any>;
+export interface QueryOptions extends BaseRequestOptions {
   json?: boolean;
 }
 
-interface FullTextQueryOptions {
+export type FindOptions = QueryOptions;
+
+/** CountOptions - no json since count() returns a number, not objects */
+export type CountOptions = BaseRequestOptions;
+
+export type GetOptions = QueryOptions;
+
+export type FirstOptions = QueryOptions;
+
+export interface FullTextOptions {
   language?: string;
   caseSensitive?: boolean;
   diacriticSensitive?: boolean;
@@ -54,11 +56,6 @@ export interface QueryJSON {
   comment?: string;
 }
 
-interface BaseAttributes {
-  createdAt: Date;
-  objectId: string;
-  updatedAt: Date;
-}
 
 /**
  * Converts a string into a regex that matches it.
@@ -646,7 +643,7 @@ class ParseQuery<T extends ParseObject = ParseObject> {
    * @returns {Promise} A promise that is resolved with the result when
    * the query completes.
    */
-  get(objectId: string, options?: QueryOptions): Promise<T> {
+  get(objectId: string, options?: GetOptions): Promise<T> {
     this.equalTo('objectId', objectId as any);
 
     const firstOptions = ParseObject._getRequestOptions(options);
@@ -675,7 +672,7 @@ class ParseQuery<T extends ParseObject = ParseObject> {
    * @returns {Promise} A promise that is resolved with the results when
    * the query completes.
    */
-  find(options?: QueryOptions): Promise<T[]> {
+  find(options?: FindOptions): Promise<T[]> {
     const findOptions = ParseObject._getRequestOptions(options);
     this._setRequestTask(findOptions);
 
@@ -759,7 +756,7 @@ class ParseQuery<T extends ParseObject = ParseObject> {
    * @returns {Promise} A promise that is resolved with the count when
    * the query completes.
    */
-  count(options?: { useMasterKey?: boolean; sessionToken?: string }): Promise<number> {
+  count(options?: CountOptions): Promise<number> {
     options = options || {};
 
     const findOptions = ParseObject._getRequestOptions(options);
@@ -843,7 +840,7 @@ class ParseQuery<T extends ParseObject = ParseObject> {
    * @returns {Promise} A promise that is resolved with the object when
    * the query completes.
    */
-  first(options: QueryOptions = {}): Promise<T | undefined> {
+  first(options: FirstOptions = {}): Promise<T | undefined> {
     const findOptions = ParseObject._getRequestOptions(options);
     this._setRequestTask(findOptions);
 
@@ -1182,10 +1179,10 @@ class ParseQuery<T extends ParseObject = ParseObject> {
     value:
       | T['attributes'][K]
       | (T['attributes'][K] extends ParseObject
-          ? Pointer
-          : T['attributes'][K] extends (infer E)[]
-            ? E
-            : never)
+        ? Pointer
+        : T['attributes'][K] extends (infer E)[]
+        ? E
+        : never)
   ): this {
     if (key && typeof key === 'object') {
       Object.entries(key).forEach(([k, val]) => this.notEqualTo(k, val as any));
@@ -1521,7 +1518,7 @@ class ParseQuery<T extends ParseObject = ParseObject> {
   fullText<K extends keyof T['attributes'] | keyof BaseAttributes>(
     key: K,
     value: string,
-    options?: FullTextQueryOptions
+    options?: FullTextOptions
   ): this {
     options = options || {};