diff --git a/src/actions/iaction.ts b/src/actions/iaction.ts
index 48804a8..2e66a96 100644
--- a/src/actions/iaction.ts
+++ b/src/actions/iaction.ts
@@ -1,5 +1,6 @@
 import { ActionType } from "../classes";
 
+/** @hidden */
 export interface IAction {
     actionType: ActionType;
 }
diff --git a/src/aggregatederror.ts b/src/aggregatederror.ts
index ee41c78..f3a5e40 100644
--- a/src/aggregatederror.ts
+++ b/src/aggregatederror.ts
@@ -1,3 +1,4 @@
+/** @hidden */
 const separator = "-----------------------------------";
 
 /**
diff --git a/src/durableorchestrationclient.ts b/src/durableorchestrationclient.ts
index 679ef20..d87fb2f 100644
--- a/src/durableorchestrationclient.ts
+++ b/src/durableorchestrationclient.ts
@@ -2,8 +2,11 @@
 
 import { HttpRequest } from "@azure/functions";
 import axios, { AxiosInstance, AxiosResponse } from "axios";
+/** @hidden */
 import cloneDeep = require("lodash/cloneDeep");
+/** @hidden */
 import process = require("process");
+/** @hidden */
 import url = require("url");
 import { isURL } from "validator";
 import { Constants, DurableOrchestrationStatus, EntityId, EntityStateResponse,
@@ -13,6 +16,7 @@ import { Constants, DurableOrchestrationStatus, EntityId, EntityStateResponse,
 } from "./classes";
 import { WebhookUtils } from "./webhookutils";
 
+/** @hidden */
 const URL = url.URL;
 
 /**
@@ -41,6 +45,7 @@ export function getClient(context: unknown): DurableOrchestrationClient {
     return new DurableOrchestrationClient(clientData);
 }
 
+/** @hidden */
 function getClientData(context: IOrchestrationFunctionContext): OrchestrationClientInputData {
     if (context.bindings) {
         const matchingInstances = Object.keys(context.bindings)
@@ -55,6 +60,7 @@ function getClientData(context: IOrchestrationFunctionContext): OrchestrationCli
     throw new Error("An orchestration client function must have an orchestrationClient input binding. Check your function.json definition.");
 }
 
+/** @hidden */
 function correctClientData(clientData: OrchestrationClientInputData): OrchestrationClientInputData {
     const returnValue = cloneDeep(clientData);
 
@@ -64,6 +70,7 @@ function correctClientData(clientData: OrchestrationClientInputData): Orchestrat
     return returnValue;
 }
 
+/** @hidden */
 function correctUrls(obj: { [key: string]: string }): { [key: string]: string } {
     const returnValue = cloneDeep(obj);
 
diff --git a/src/durableorchestrationcontext.ts b/src/durableorchestrationcontext.ts
index ebfdaaf..d661454 100644
--- a/src/durableorchestrationcontext.ts
+++ b/src/durableorchestrationcontext.ts
@@ -50,7 +50,9 @@ export class DurableOrchestrationContext {
     public currentUtcDateTime: Date;
 
     /**
-     *
+     * Just an entry point to reference the methods in [[ITaskMethods]].
+     * Methods to handle collections of pending actions represented by [[Task]]
+     * instances. For use in parallelization operations.
      */
     public Task: ITaskMethods;
 
diff --git a/src/entities/durablelock.ts b/src/entities/durablelock.ts
index fbcdd12..1b195b6 100644
--- a/src/entities/durablelock.ts
+++ b/src/entities/durablelock.ts
@@ -1,4 +1,5 @@
 /**
+ * @hidden
  * For use with locking operations.
  * TODO: improve this
  */
diff --git a/src/entities/lockstate.ts b/src/entities/lockstate.ts
index e0c8400..cc46bf7 100644
--- a/src/entities/lockstate.ts
+++ b/src/entities/lockstate.ts
@@ -1,6 +1,7 @@
 import { EntityId } from "../classes";
 
 /**
+ * @hidden
  * Returned by [DurableOrchestrationContext].[isLocked] and
  * [DurableEntityContext].[isLocked].
  */
diff --git a/src/entities/signal.ts b/src/entities/signal.ts
index 61532c3..3d3ab7a 100644
--- a/src/entities/signal.ts
+++ b/src/entities/signal.ts
@@ -1,5 +1,6 @@
 import { EntityId } from "../classes";
 
+/** @hidden */
 export class Signal {
     constructor(
         public readonly target: EntityId,
diff --git a/src/guidmanager.ts b/src/guidmanager.ts
index 0c81e25..335fa88 100644
--- a/src/guidmanager.ts
+++ b/src/guidmanager.ts
@@ -1,4 +1,5 @@
 import * as crypto from "crypto";
+/** @hidden */
 import uuidv5 = require("uuid/v5");
 import { Utils } from "./classes";
 
@@ -25,6 +26,7 @@ export class GuidManager {
     }
 }
 
+/** @hidden */
 enum DeterministicGuidVersion {
     V3 = 0,
     V5 = 1,
diff --git a/src/orchestrationfailureerror.ts b/src/orchestrationfailureerror.ts
index ae61eed..d2599b9 100644
--- a/src/orchestrationfailureerror.ts
+++ b/src/orchestrationfailureerror.ts
@@ -1,8 +1,9 @@
 import { OrchestratorState } from "./classes";
-
+/** @hidden */
 const outOfProcDataLabel = "\n\n$OutOfProcData$:";
 
 /**
+ * @hidden
  * A wrapper for all errors thrown within an orchestrator function. This exception will embed
  * the orchestrator state in a way that the C# extension knows how to read so that it can replay the
  * actions scheduled before throwing an exception. This prevents non-determinism errors in Durable Task.
diff --git a/src/tasks/task.ts b/src/tasks/task.ts
index 8299b9c..b69e7b6 100644
--- a/src/tasks/task.ts
+++ b/src/tasks/task.ts
@@ -10,6 +10,9 @@ import { TaskBase } from "./taskinterfaces";
  * [[DurableOrchestrationContext]] operation is not called with `yield`. They
  * are useful for parallelization and timeout operations in conjunction with
  * Task.all and Task.any.
+ * 
+ * We discourage the usage of `instanceof`-style guards on this type,
+ * as it is subject to change in the future.
  *
  * @example Wait for all parallel operations to complete
  * ```javascript
@@ -35,6 +38,7 @@ import { TaskBase } from "./taskinterfaces";
  */
 export class Task implements TaskBase {
     /**
+     * @hidden
      * Used to keep track of how many times the task has been yielded to avoid
      * scheduling the internal action multiple times _Internal use only._
      */
@@ -52,6 +56,7 @@ export class Task implements TaskBase {
          */
         public readonly isFaulted: boolean,
         /**
+         * @hidden
          * The scheduled action represented by the task. _Internal use only._
          */
         public readonly action: IAction,
@@ -60,10 +65,12 @@ export class Task implements TaskBase {
          */
         public readonly result?: unknown,
         /**
+         * @hidden
          * The timestamp of the task.
          */
         public readonly timestamp?: Date,
         /**
+         * @hidden
          * The ID number of the task. _Internal use only._
          */
         public readonly id?: number,
@@ -75,12 +82,14 @@ export class Task implements TaskBase {
         public readonly exception?: Error | undefined,
 
         /**
+         * @hidden
          * The index in the history state where the task was marked completed. _Internal use only._
          */
         public readonly completionIndex?: number,
     ) { }
 
     /**
+     * @hidden
      * _Internal use only._
      */
     public yieldNewActions(): IAction[] {
diff --git a/src/tasks/taskfactory.ts b/src/tasks/taskfactory.ts
index ae84a50..3d87a0e 100644
--- a/src/tasks/taskfactory.ts
+++ b/src/tasks/taskfactory.ts
@@ -4,6 +4,7 @@ import { TaskBase} from "./taskinterfaces";
 import { TaskSet } from "./taskset";
 import { TimerTask } from "./timertask";
 
+/** @hidden */
 export class TaskFactory {
     public static UncompletedTask(action: IAction): Task {
         return new Task(false, false, action);
diff --git a/src/tasks/taskfilter.ts b/src/tasks/taskfilter.ts
index 2aa2e80..1e5a7b2 100644
--- a/src/tasks/taskfilter.ts
+++ b/src/tasks/taskfilter.ts
@@ -2,6 +2,7 @@ import { Task } from "./task";
 import { CompletedTask, FailedTask, SuccessfulTask, TaskBase, UncompletedTask } from "./taskinterfaces";
 import { TaskSet } from "./taskset";
 
+/** @hidden */
 export class TaskFilter {
     public static CompareFinishedTime(taskA: CompletedTask, taskB: CompletedTask) {
         if (taskA.completionIndex > taskB.completionIndex) { return 1; }
diff --git a/src/tasks/taskinterfaces.ts b/src/tasks/taskinterfaces.ts
index 25bbcf7..e1f5ef5 100644
--- a/src/tasks/taskinterfaces.ts
+++ b/src/tasks/taskinterfaces.ts
@@ -1,29 +1,34 @@
 import { IAction } from "../classes";
 
  // Base interfaces
+/** @hidden */
 export interface TaskBase {
     readonly isCompleted: boolean;
     readonly isFaulted: boolean;
     yieldNewActions(): IAction[];
  }
 
+/** @hidden */
 export interface UncompletedTask extends TaskBase {
     readonly isCompleted: false;
     readonly isFaulted: false;
 }
 
+/** @hidden */
 export interface CompletedTask extends TaskBase {
     readonly completionIndex: number;
     readonly isCompleted: true;
     readonly result: unknown | undefined;
 }
 
+/** @hidden */
 export interface SuccessfulTask extends CompletedTask {
     readonly isFaulted: false;
     readonly result: unknown;
     readonly exception: undefined;
 }
 
+/** @hidden */
 export interface FailedTask extends CompletedTask {
     readonly isFaulted: true;
     readonly exception: Error;
diff --git a/src/tasks/timertask.ts b/src/tasks/timertask.ts
index 89016db..4db4113 100644
--- a/src/tasks/timertask.ts
+++ b/src/tasks/timertask.ts
@@ -45,6 +45,7 @@ export class TimerTask extends Task {
     constructor(
         isCompleted: boolean,
         /**
+         * @hidden
          * The scheduled action represented by the task. _Internal use only._
          */
         public readonly action: CreateTimerAction,