docs(typedoc): hide internal functions

Author: mumenthalers

src/dynamo/expression/create-if-not-exists-condition.function.ts

@@ -5,6 +5,9 @@ import { hasSortKey, Metadata } from '../../decorator/metadata/metadata'
 import { attribute } from './logical-operator/public.api'
 import { ConditionExpressionDefinitionFunction } from './type/condition-expression-definition-function'
 
+/**
+ * @hidden
+ */
 export function createIfNotExistsCondition<T>(metadata: Metadata<T>): ConditionExpressionDefinitionFunction[] {
   const conditionDefFns: ConditionExpressionDefinitionFunction[] = [
     attribute<T>(metadata.getPartitionKey()).attributeNotExists(),

src/dynamo/expression/functions/is-no-param-function-operator.function.ts

@@ -6,6 +6,7 @@ import { FunctionOperator } from '../type/function-operator.type'
 
 /**
  * @returns {boolean} Returns true for all function operators with no param false otherwise
+ * @hidden
  */
 export function isNoParamFunctionOperator(operator: FunctionOperator): boolean {
   return NON_PARAM_FUNCTION_OPERATORS.includes(operator)

src/dynamo/expression/functions/operator-parameter-arity.function.ts

@@ -10,6 +10,7 @@ import { isNoParamFunctionOperator } from './is-no-param-function-operator.funct
  * returns this value
  *
  * @returns {number} The amount of required method parameters when calling an operator function
+ * @hidden
  */
 export function operatorParameterArity(operator: ConditionOperator): number {
   if (isFunctionOperator(operator) && isNoParamFunctionOperator(operator)) {

src/dynamo/expression/logical-operator/and.function.ts

@@ -6,6 +6,10 @@ import { mergeConditions } from './merge-conditions.function'
 
 /**
  * function to combine multiple conditions with 'and'
+ * @example
+ * ```typescript
+ * and(attribute('propA').eq('foo'), attribute('propB').eq('bar'))
+ * ```
  */
 export function and(
   ...conditionDefinitionFns: ConditionExpressionDefinitionFunction[]

src/dynamo/expression/logical-operator/attribute.function.ts

@@ -10,8 +10,9 @@ import {
 
 /**
  * Use this method when accessing a top level attribute of a model with strict typing of the value in chained function
- *
+ * @example
  * ```typescript
+ *
  * @Model()
  * class Person{
  *
@@ -39,6 +40,10 @@ export function attribute2<T, K extends keyof T>(
 
 /**
  * Use this method when accessing a top level attribute of a model to have type checking of the attributePath
+ * @example
+ * ```typescript
+ * attribute('myProp').eq('foo')
+ * ```
  */
 export function attribute<T>(attributePath: keyof T): ConditionExpressionDefinitionChain
 

src/dynamo/expression/logical-operator/not.function.ts

@@ -7,6 +7,10 @@ import { Expression } from '../type/expression.type'
 
 /**
  * function to negate a condition
+ * @example
+ * ```typescript
+ * not(attribute('propA').eq('foo'))
+ * ```
  */
 export function not(
   conditionDefinitionFn: ConditionExpressionDefinitionFunction,

src/dynamo/expression/logical-operator/or.function.ts

@@ -6,7 +6,10 @@ import { mergeConditions } from './merge-conditions.function'
 
 /**
  * function to combine multiple conditions with or
- * @param conditionDefinitionFns
+ * @example
+ * ```typescript
+ * or(attribute('propA').eq('foo'), attribute('propB').eq('bar'))
+ * ```
  */
 export function or(
   ...conditionDefinitionFns: ConditionExpressionDefinitionFunction[]

src/dynamo/expression/logical-operator/update.function.ts

@@ -10,7 +10,7 @@ import {
 
 /**
  * Use this method when accessing a top level attribute of a model with strict typing of the value in chained function
- *
+ * @example
  * ```typescript
  * @Model()
  * class Person {
@@ -38,6 +38,10 @@ export function update2<T, K extends keyof T>(
 
 /**
  * Use this method when accessing a top level attribute of a model to have type checking for attributePath
+ * @example
+ * ```typescript
+ * update('myProp').set('foo')
+ * ```
  */
 export function update<T>(attributePath: keyof T): UpdateExpressionDefinitionChain
 

src/dynamo/expression/param-util.ts

@@ -56,6 +56,9 @@ export function addExpression(
   }
 }
 
+/**
+ * @hidden
+ */
 type UpdateExpressionsByKeyword = Record<UpdateActionKeyword, string>
 
 /**

src/dynamo/expression/prepare-and-add-update-expressions.function.ts

@@ -10,6 +10,9 @@ import { UpdateActionKeyword } from './type/update-action-keyword.type'
 import { UpdateExpressionDefinitionFunction } from './type/update-expression-definition-function'
 import { UpdateExpression } from './type/update-expression.type'
 
+/**
+ * @hidden
+ */
 export function prepareAndAddUpdateExpressions(
   metadata: Metadata<any>,
   params: DynamoDB.UpdateItemInput | DynamoDB.Update,