JsonSchemaGeneratorBuilder (Apache Juneau 8.2.0)

java.lang.Object
- org.apache.juneau.ContextBuilder
- - org.apache.juneau.BeanContextBuilder
  - - org.apache.juneau.BeanTraverseBuilder
    - - org.apache.juneau.jsonschema.JsonSchemaGeneratorBuilder

public class JsonSchemaGeneratorBuilder
extends BeanTraverseBuilder

Builder class for building instances of JSON Schema generators.

Constructor Summary

Constructors
Constructor and Description

JsonSchemaGeneratorBuilder()
Constructor, default settings.

JsonSchemaGeneratorBuilder(PropertyStore ps)
Constructor.

Constructors
Constructor and Description
`JsonSchemaGeneratorBuilder()` Constructor, default settings.
`JsonSchemaGeneratorBuilder(PropertyStore ps)` Constructor.

Method Summary

All Methods Instance Methods Concrete Methods Deprecated Methods
Modifier and Type	Method and Description
`JsonSchemaGeneratorBuilder`	`add(Map<String,Object> properties)` Adds multiple free-form configuration properties on this object without first clearing out any previous values.
`JsonSchemaGeneratorBuilder`	`addDescriptionsTo(String value)` JsonSchemaGenerator configuration property: Add descriptions.
`JsonSchemaGeneratorBuilder`	`addExamplesTo(String value)` JsonSchemaGenerator configuration property: Add examples.
`JsonSchemaGeneratorBuilder`	`addTo(String name, Object value)` Adds a free-form value to a SET property.
`JsonSchemaGeneratorBuilder`	`allowNestedDescriptions()` JsonSchemaGenerator configuration property: Allow nested descriptions.
`JsonSchemaGeneratorBuilder`	`allowNestedDescriptions(boolean value)` Deprecated.
`JsonSchemaGeneratorBuilder`	`allowNestedExamples()` JsonSchemaGenerator configuration property: Allow nested examples.
`JsonSchemaGeneratorBuilder`	`allowNestedExamples(boolean value)` Deprecated.
`JsonSchemaGeneratorBuilder`	`annotations(Annotation... values)` BeanContext configuration property: Dynamically applied POJO annotations.
`JsonSchemaGeneratorBuilder`	`appendTo(String name, Object value)` Adds a free-form value to the end of a LIST property.
`JsonSchemaGeneratorBuilder`	`apply(PropertyStore copyFrom)` Copies the settings from the specified property store into this builder.
`JsonSchemaGeneratorBuilder`	`applyAnnotations(AnnotationList al, VarResolverSession r)` Applies a set of annotations to this property store.
`JsonSchemaGeneratorBuilder`	`applyAnnotations(Class<?>... fromClasses)` Applies any of the various @XConfig annotations on the specified class to this context.
`JsonSchemaGeneratorBuilder`	`applyAnnotations(Method... fromMethods)` Applies any of the various @XConfig annotations on the specified method to this context.
`JsonSchemaGeneratorBuilder`	`beanClassVisibility(Visibility value)` BeanContext configuration property: Minimum bean class visibility.
`JsonSchemaGeneratorBuilder`	`beanConstructorVisibility(Visibility value)` BeanContext configuration property: Minimum bean constructor visibility.
`JsonSchemaGeneratorBuilder`	`beanDefMapper(BeanDefMapper value)` JsonSchemaGenerator configuration property: Bean schema definition mapper.
`JsonSchemaGeneratorBuilder`	`beanDefMapper(Class<? extends BeanDefMapper> value)` JsonSchemaGenerator configuration property: Schema definition mapper.
`JsonSchemaGeneratorBuilder`	`beanFieldVisibility(Visibility value)` BeanContext configuration property: Minimum bean field visibility.
`JsonSchemaGeneratorBuilder`	`beanInterceptor(Class<?> on, Class<? extends BeanInterceptor<?>> value)` Bean interceptor.
`JsonSchemaGeneratorBuilder`	`beanMapPutReturnsOldValue()` BeanContext configuration property: BeanMap.put() returns old property value.
`JsonSchemaGeneratorBuilder`	`beanMethodVisibility(Visibility value)` BeanContext configuration property: Minimum bean method visibility.
`JsonSchemaGeneratorBuilder`	`beansDontRequireSomeProperties()` BeanContext configuration property: Beans require at least one property.
`JsonSchemaGeneratorBuilder`	`beansRequireDefaultConstructor()` BeanContext configuration property: Beans require no-arg constructors.
`JsonSchemaGeneratorBuilder`	`beansRequireSerializable()` BeanContext configuration property: Beans require Serializable interface.
`JsonSchemaGeneratorBuilder`	`beansRequireSettersForGetters()` BeanContext configuration property: Beans require setters for getters.
`JsonSchemaGeneratorBuilder`	`bpi(Class<?> beanClass, String properties)` Bean property includes.
`JsonSchemaGeneratorBuilder`	`bpi(Map<String,Object> values)` Bean property includes.
`JsonSchemaGeneratorBuilder`	`bpi(String beanClassName, String properties)` Bean property includes.
`JsonSchemaGeneratorBuilder`	`bpro(Class<?> beanClass, String properties)` Read-only bean properties.
`JsonSchemaGeneratorBuilder`	`bpro(Map<String,Object> values)` Read-only bean properties.
`JsonSchemaGeneratorBuilder`	`bpro(String beanClassName, String properties)` Read-only bean properties.
`JsonSchemaGeneratorBuilder`	`bpwo(Class<?> beanClass, String properties)` Write-only bean properties.
`JsonSchemaGeneratorBuilder`	`bpwo(Map<String,Object> values)` Write-only bean properties.
`JsonSchemaGeneratorBuilder`	`bpwo(String beanClassName, String properties)` Write-only bean properties.
`JsonSchemaGeneratorBuilder`	`bpx(Class<?> beanClass, String properties)` Bean property excludes.
`JsonSchemaGeneratorBuilder`	`bpx(Map<String,Object> values)` Bean property excludes.
`JsonSchemaGeneratorBuilder`	`bpx(String beanClassName, String properties)` Bean property excludes.
`JsonSchemaGenerator`	`build()` Build the object.
`JsonSchemaGeneratorBuilder`	`debug()` Context configuration property: Debug mode.
`JsonSchemaGeneratorBuilder`	`defaultSchema(Class<?> c, OMap schema)` JsonSchemaGenerator configuration property: Default schemas.
`JsonSchemaGeneratorBuilder`	`detectRecursions()` BeanTraverse configuration property: Automatically detect POJO recursions.
`JsonSchemaGeneratorBuilder`	`dictionary(Object... values)` BeanContext configuration property: Bean dictionary.
`JsonSchemaGeneratorBuilder`	`dictionaryOn(Class<?> on, Class<?>... values)` BeanContext configuration property: Bean dictionary.
`JsonSchemaGeneratorBuilder`	`dontIgnorePropertiesWithoutSetters()` BeanContext configuration property: Ignore properties without setters.
`JsonSchemaGeneratorBuilder`	`dontIgnoreTransientFields()` BeanContext configuration property: Ignore transient fields.
`JsonSchemaGeneratorBuilder`	`dontIgnoreUnknownNullBeanProperties()` BeanContext configuration property: Ignore unknown properties with null values.
`JsonSchemaGeneratorBuilder`	`dontUseInterfaceProxies()` BeanContext configuration property: Use interface proxies.
`<T> JsonSchemaGeneratorBuilder`	`example(Class<T> pojoClass, T o)` BeanContext configuration property: POJO example.
`<T> JsonSchemaGeneratorBuilder`	`exampleJson(Class<T> pojoClass, String json)` BeanContext configuration property: POJO example.
`JsonSchemaGeneratorBuilder`	`fluentSetters()` BeanContext configuration property: Find fluent setters.
`JsonSchemaGeneratorBuilder`	`fluentSetters(Class<?> on)` BeanContext configuration property: Find fluent setters.
`JsonSchemaGeneratorBuilder`	`ignoreInvocationExceptionsOnGetters()` BeanContext configuration property: Ignore invocation errors on getters.
`JsonSchemaGeneratorBuilder`	`ignoreInvocationExceptionsOnSetters()` BeanContext configuration property: Ignore invocation errors on setters.
`JsonSchemaGeneratorBuilder`	`ignoreRecursions()` BeanTraverse configuration property: Ignore recursion errors.
`JsonSchemaGeneratorBuilder`	`ignoreTypes(String value)` JsonSchemaGenerator configuration property: Ignore types from schema definitions.
`JsonSchemaGeneratorBuilder`	`ignoreUnknownBeanProperties()` BeanContext configuration property: Ignore unknown properties.
`JsonSchemaGeneratorBuilder`	`implClass(Class<?> interfaceClass, Class<?> implClass)` BeanContext configuration property: Implementation classes.
`JsonSchemaGeneratorBuilder`	`implClasses(Map<Class<?>,Class<?>> values)` BeanContext configuration property: Implementation classes.
`JsonSchemaGeneratorBuilder`	`initialDepth(int value)` BeanTraverse configuration property: Initial depth.
`JsonSchemaGeneratorBuilder`	`interfaceClass(Class<?> on, Class<?> value)` Identifies a class to be used as the interface class for the specified class and all subclasses.
`JsonSchemaGeneratorBuilder`	`interfaces(Class<?>... value)` Identifies a set of interfaces.
`JsonSchemaGeneratorBuilder`	`locale(Locale value)` Context configuration property: Locale.
`JsonSchemaGeneratorBuilder`	`maxDepth(int value)` BeanTraverse configuration property: Max traversal depth.
`JsonSchemaGeneratorBuilder`	`mediaType(MediaType value)` Context configuration property: Media type.
`JsonSchemaGeneratorBuilder`	`notBeanClasses(Object... values)` BeanContext configuration property: Bean class exclusions.
`JsonSchemaGeneratorBuilder`	`notBeanPackages(Object... values)` BeanContext configuration property: Bean package exclusions.
`JsonSchemaGeneratorBuilder`	`prependTo(String name, Object value)` Adds a free-form value to the beginning of a LIST property.
`JsonSchemaGeneratorBuilder`	`propertyNamer(Class<?> on, Class<? extends PropertyNamer> value)` Bean property namer
`JsonSchemaGeneratorBuilder`	`propertyNamer(Class<? extends PropertyNamer> value)` BeanContext configuration property: Bean property namer
`JsonSchemaGeneratorBuilder`	`putAllTo(String name, Object value)` Adds or overwrites multiple free-form entries in a MAP property.
`JsonSchemaGeneratorBuilder`	`putTo(String name, String key, Object value)` Adds or overwrites a free-form entry in a MAP property.
`JsonSchemaGeneratorBuilder`	`removeFrom(String name, Object value)` Removes a free-form value from a SET, LIST, or MAP property.
`JsonSchemaGeneratorBuilder`	`set(Map<String,Object> properties)` Sets multiple free-form configuration properties on this object replacing all previous values.
`JsonSchemaGeneratorBuilder`	`set(String name, Object value)` Sets a free-form configuration property on this object.
`JsonSchemaGeneratorBuilder`	`sortProperties()` BeanContext configuration property: Sort bean properties.
`JsonSchemaGeneratorBuilder`	`sortProperties(Class<?>... on)` Sort bean properties.
`JsonSchemaGeneratorBuilder`	`stopClass(Class<?> on, Class<?> value)` Identifies a stop class for the annotated class.
`JsonSchemaGeneratorBuilder`	`swaps(Object... values)` BeanContext configuration property: Java object swaps.
`JsonSchemaGeneratorBuilder`	`timeZone(TimeZone value)` Context configuration property: TimeZone.
`JsonSchemaGeneratorBuilder`	`typeName(Class<?> on, String value)` An identifying name for this class.
`JsonSchemaGeneratorBuilder`	`typePropertyName(Class<?> on, String value)` BeanContext configuration property: Bean type property name.
`JsonSchemaGeneratorBuilder`	`typePropertyName(String value)` BeanContext configuration property: Bean type property name.
`JsonSchemaGeneratorBuilder`	`useBeanDefs()` JsonSchemaGenerator configuration property: Use bean definitions.
`JsonSchemaGeneratorBuilder`	`useBeanDefs(boolean value)` Deprecated.
`JsonSchemaGeneratorBuilder`	`useEnumNames()` BeanContext configuration property: Use enum names.
`JsonSchemaGeneratorBuilder`	`useJavaBeanIntrospector()` BeanContext configuration property: Use Java Introspector.

Methods inherited from class org.apache.juneau.BeanTraverseBuilder
detectRecursions, ignoreRecursions

Methods inherited from class org.apache.juneau.ContextBuilder
build, getPropertyStore, getPropertyStoreBuilder, peek, peek

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Constructor Detail
  - JsonSchemaGeneratorBuilder
```
public JsonSchemaGeneratorBuilder()
```
    Constructor, default settings.
  - JsonSchemaGeneratorBuilder
```
public JsonSchemaGeneratorBuilder(PropertyStore ps)
```
    Constructor.
    
    Parameters:
    
    ps - The initial configuration settings for this builder.
- Method Detail
  - build
```
public JsonSchemaGenerator build()
```
    Description copied from class: ContextBuilder
    
    Build the object.
    
    Overrides:
    
    build in class BeanTraverseBuilder
    
    Returns:
    
    The built object.
    Subsequent calls to this method will create new instances (unless context object is cacheable).
  - addDescriptionsTo
```
public JsonSchemaGeneratorBuilder addDescriptionsTo(String value)
```
    JsonSchemaGenerator configuration property: Add descriptions.
    Identifies which categories of types that descriptions should be automatically added to generated schemas.
    The description is the result of calling ClassMeta.getFullName().
    - JsonSchemaGenerator.JSONSCHEMA_addDescriptionsTo
    Parameters:
    
    value - The new value for this property.
    The default is an empty string.
    
    Returns:
    
    This object (for method chaining).
  - addExamplesTo
```
public JsonSchemaGeneratorBuilder addExamplesTo(String value)
```
    JsonSchemaGenerator configuration property: Add examples.
    Identifies which categories of types that examples should be automatically added to generated schemas.
    The examples come from calling ClassMeta.getExample(BeanSession) which in turn gets examples from the following:
    - Example
    - BeanContext.BEAN_examples
    - JsonSchemaGenerator.JSONSCHEMA_addExamplesTo
    Parameters:
    
    value - The new value for this property.
    The default is an empty string.
    
    Returns:
    
    This object (for method chaining).
  - allowNestedDescriptions
```
@Deprecated
public JsonSchemaGeneratorBuilder allowNestedDescriptions(boolean value)
```
    Deprecated.
    
    JsonSchemaGenerator configuration property: Allow nested descriptions.
    Deprecated - Use allowNestedDescriptions()
  - allowNestedDescriptions
```
public JsonSchemaGeneratorBuilder allowNestedDescriptions()
```
    JsonSchemaGenerator configuration property: Allow nested descriptions.
    Identifies whether nested descriptions are allowed in schema definitions.
    - JsonSchemaGenerator.JSONSCHEMA_allowNestedDescriptions
    Returns:
    
    This object (for method chaining).
  - allowNestedExamples
```
@Deprecated
public JsonSchemaGeneratorBuilder allowNestedExamples(boolean value)
```
    Deprecated.
    
    JsonSchemaGenerator configuration property: Allow nested examples.
    Deprecated - Use allowNestedExamples()
  - allowNestedExamples
```
public JsonSchemaGeneratorBuilder allowNestedExamples()
```
    JsonSchemaGenerator configuration property: Allow nested examples.
    Identifies whether nested examples are allowed in schema definitions.
    - JsonSchemaGenerator.JSONSCHEMA_allowNestedExamples
    Returns:
    
    This object (for method chaining).
  - beanDefMapper
```
public JsonSchemaGeneratorBuilder beanDefMapper(Class<? extends BeanDefMapper> value)
```
    JsonSchemaGenerator configuration property: Schema definition mapper.
    Interface to use for converting Bean classes to definition IDs and URIs.
    Used primarily for defining common definition sections for beans in Swagger JSON.
    This setting is ignored if JsonSchemaGenerator.JSONSCHEMA_useBeanDefs is not enabled.
    - JsonSchemaGenerator.JSONSCHEMA_beanDefMapper
    Parameters:
    
    value - The new value for this property.
    The default is BasicBeanDefMapper.
    
    Returns:
    
    This object (for method chaining).
  - beanDefMapper
```
public JsonSchemaGeneratorBuilder beanDefMapper(BeanDefMapper value)
```
    JsonSchemaGenerator configuration property: Bean schema definition mapper.
    Interface to use for converting Bean classes to definition IDs and URIs.
    Used primarily for defining common definition sections for beans in Swagger JSON.
    This setting is ignored if JsonSchemaGenerator.JSONSCHEMA_useBeanDefs is not enabled.
    - JsonSchemaGenerator.JSONSCHEMA_beanDefMapper
    Parameters:
    
    value - The new value for this property.
    The default is BasicBeanDefMapper.
    
    Returns:
    
    This object (for method chaining).
  - defaultSchema
```
public JsonSchemaGeneratorBuilder defaultSchema(Class<?> c,
                                                OMap schema)
```
    JsonSchemaGenerator configuration property: Default schemas.
    Allows you to override or provide custom schema information for particular class types.
    Keys are full class names.
    - JsonSchemaGenerator.JSONSCHEMA_defaultSchemas
    Parameters:
    
    c - The class to define a default schema for.
    
    schema - The schema.
    
    Returns:
    
    This object (for method chaining).
  - ignoreTypes
```
public JsonSchemaGeneratorBuilder ignoreTypes(String value)
```
    JsonSchemaGenerator configuration property: Ignore types from schema definitions.
    Description:
    
    Defines class name patterns that should be ignored when generating schema definitions in the generated Swagger documentation.
    Example:
    
    // Don't generate schema for any prototype packages or the class named 'Swagger'. @Rest( properties={ @Property(name=JSONSCHEMA_ignoreTypes, value="Swagger,*.proto.*") } public class MyResource {...}
    
    Parameters:
    
    value - A comma-delimited list of types to ignore.
    
    Returns:
    
    This object (for method chaining).
  - useBeanDefs
```
@Deprecated
public JsonSchemaGeneratorBuilder useBeanDefs(boolean value)
```
    Deprecated.
    
    JsonSchemaGenerator configuration property: Use bean definitions.
    Deprecated - Use useBeanDefs()
  - useBeanDefs
```
public JsonSchemaGeneratorBuilder useBeanDefs()
```
    JsonSchemaGenerator configuration property: Use bean definitions.
    When enabled, schemas on beans will be serialized as the following:
    { type: 'object', '$ref': '#/definitions/TypeId' }
    
    The definitions can then be retrieved from the session using JsonSchemaGeneratorSession.getBeanDefs().
    Definitions can also be added programmatically using JsonSchemaGeneratorSession.addBeanDef(String, OMap).
    
    Returns:
    
    This object (for method chaining).
  - add
```
public JsonSchemaGeneratorBuilder add(Map<String,Object> properties)
```
    Description copied from class: ContextBuilder
    Adds multiple free-form configuration properties on this object without first clearing out any previous values.
    Identical in function to ContextBuilder.set(String, Object) but allows you to specify multiple values at once.
    Example:
    
    // Create a serializer that sorts bean properties. WriterSerializer s = JsonSerializer .create() .sortMaps() .sortProperties() .build(); // Same, but use generic add() method. WriterSerializer s = JsonSerializer .create() .add( AMap.of( BEAN_sortMaps, true, BEAN_sortProperties, true ) ) .build();
    - PropertyStore
    - ContextBuilder.set(String, Object)
    Overrides:
    
    add in class BeanTraverseBuilder
    
    Parameters:
    properties - The properties to set on this class.
    The keys must be strings.
    The valid value types depend on the property type:
    
    "s" - Any Object converted to a String using value.toString().
    "b" - Any Object converted to a Boolean using Boolean.parseBoolean(value.toString()).
    "i" - Any Object converted to an Integer using Integer.valueOf(value.toString()).
    "c" - Only Class objects are allowed.
    "o" - Left as-is.
    "ss","si","sc" - Any collection or array of any convertible Objects or a JSON Array string.
    "ls","li","lc","lo" - Any collection or array of any convertible Objects or a JSON Array string.
    "sms","smi","smc","smo" - Any sorted map of any convertible Objects or a JSON Object string.
    "oms","omi","omc","omo" - Any ordered map of any convertible Objects or a JSON Object string.
    Returns:
    
    This object (for method chaining).
  - addTo
```
public JsonSchemaGeneratorBuilder addTo(String name,
                                        Object value)
```
    Description copied from class: ContextBuilder
    Adds a free-form value to a SET property.
    SET properties are those properties with one of the following type parts:
    - "ss" - TreeSet<String>
    - "si" - TreeSet<Integer>
    - "sc" - TreeSet<Class>
    For example, the BeanContext.BEAN_notBeanClasses property which has the value "BeanContext.notBeanClasses.sc".
    Example:
    
    // Create a serializer that forces MyNotBean classes to be converted to strings. WriterSerializer s = JsonSerializer .create() .notBeanClasses(MyNotBean.class) .build(); // Same, but use generic addTo() method. WriterSerializer s = JsonSerializer .create() .addTo(BEAN_notBeanClasses, MyNotBean.class) .build();
    - PropertyStore
    - ContextBuilder.set(String, Object)
    Overrides:
    
    addTo in class BeanTraverseBuilder
    
    Parameters:
    
    name - The property name.
    value - The new value to add to the SET property.
    The valid value types depend on the property type:
    
    "ss" - Any Object converted to a String using value.toString().
    "si" - Any Object converted to an Integer using Integer.valueOf(value.toString()).
    "sc" - Only Class objects are allowed.
    Returns:
    
    This object (for method chaining).
  - appendTo
```
public JsonSchemaGeneratorBuilder appendTo(String name,
                                           Object value)
```
    Description copied from class: ContextBuilder
    Adds a free-form value to the end of a LIST property.
    LIST properties are those properties with one of the following type parts:
    - "ls" - Linkedlist<String>
    - "li" - Linkedlist<Integer>
    - "lc" - Linkedlist<Class>
    - "lo" - Linkedlist<Object>
    For example, the BeanContext.BEAN_swaps property which has the value "BeanContext.swaps.lo".
    Example:
    
    // Create a serializer that converts Temporal objects to Basic ISO date strings. WriterSerializer s = JsonSerializer .create() .swaps(TemoralCalendarSwap.BasicIsoDate.class) .build(); // Same, but use generic appendTo() method. WriterSerializer s = JsonSerializer .create() .appendTo(BEAN_swaps, TemoralCalendarSwap.BasicIsoDate.class) .build();
    - PropertyStore
    - ContextBuilder.set(String, Object)
    Overrides:
    
    appendTo in class BeanTraverseBuilder
    
    Parameters:
    
    name - The property name.
    value - The new value to add to the LIST property.
    The valid value types depend on the property type:
    
    "ls" - Any Object converted to a String using value.toString().
    "li" - Any Object converted to an Integer using Integer.valueOf(value.toString()).
    "lc" - Only Class objects are allowed.
    "lo" - Left as-is.
    Returns:
    
    This object (for method chaining).
  - apply
```
public JsonSchemaGeneratorBuilder apply(PropertyStore copyFrom)
```
    Description copied from class: ContextBuilder
    
    Copies the settings from the specified property store into this builder.
    Example:
    
    // Create a free-form set of properties. PropertyStore ps = PropertyStore .create() .set(BEAN_sortMaps, true) .set(BEAN_sortProperties, true) .build(); // Create a serializer that uses those settings. WriterSerializer s = JsonSerializer .create() .apply(ps) .build();
    
    Overrides:
    
    apply in class BeanTraverseBuilder
    
    Parameters:
    
    copyFrom - The property store whose settings are being copied.
    
    Returns:
    
    This object (for method chaining).
  - applyAnnotations
```
public JsonSchemaGeneratorBuilder applyAnnotations(Class<?>... fromClasses)
```
    Description copied from class: ContextBuilder
    Applies any of the various @XConfig annotations on the specified class to this context.
    Any annotations found that themselves are annotated with PropertyStoreApply will be resolved and applied as properties to this builder. These annotations include:
    Annotations on classes are appended in the following order:
    1. On the package of this class.
    2. On interfaces ordered parent-to-child.
    3. On parent classes ordered parent-to-child.
    4. On this class.
    The default var resolver VarResolver.DEFAULT is used to resolve any variables in annotation field values.
    Example:
    
    // A class annotated with a config annotation. @BeanConfig(sortProperties="$S{sortProperties,false}") public class MyClass {...} // Apply any settings found on the annotations. WriterSerializer s = JsonSerializer .create() .applyAnnotations(MyClass.class) .build();
    Overrides:
    
    applyAnnotations in class BeanTraverseBuilder
    
    Parameters:
    
    fromClasses - The classes on which the annotations are defined.
    
    Returns:
    
    This object (for method chaining).
  - applyAnnotations
```
public JsonSchemaGeneratorBuilder applyAnnotations(Method... fromMethods)
```
    Description copied from class: ContextBuilder
    Applies any of the various @XConfig annotations on the specified method to this context.
    Any annotations found that themselves are annotated with PropertyStoreApply will be resolved and applied as properties to this builder. These annotations include:
    Annotations on methods are appended in the following order:
    1. On the package of the method class.
    2. On interfaces ordered parent-to-child.
    3. On parent classes ordered parent-to-child.
    4. On the method class.
    5. On this method and matching methods ordered parent-to-child.
    The default var resolver VarResolver.DEFAULT is used to resolve any variables in annotation field values.
    Example:
    
    // A method annotated with a config annotation. public class MyClass { @BeanConfig(sortProperties="$S{sortProperties,false}") public void myMethod() {...} } // Apply any settings found on the annotations. WriterSerializer s = JsonSerializer .create() .applyAnnotations(MyClass.class.getMethod("myMethod")) .build();
    Overrides:
    
    applyAnnotations in class BeanTraverseBuilder
    
    Parameters:
    
    fromMethods - The methods on which the annotations are defined.
    
    Returns:
    
    This object (for method chaining).
  - applyAnnotations
```
public JsonSchemaGeneratorBuilder applyAnnotations(AnnotationList al,
                                                   VarResolverSession r)
```
    Description copied from class: ContextBuilder
    
    Applies a set of annotations to this property store.
    The AnnotationList object is an ordered list of annotations and the classes/methods/packages they were found on.
    Example:
    
    // A class annotated with a config annotation. @BeanConfig(sortProperties="$S{sortProperties,false}") public class MyClass {...} // Find all annotations that themselves are annotated with @PropertyStoreApply. AnnotationList al = ClassInfo.of(MyClass.class) .getAnnotationList(ConfigAnnotationFilter.INSTANCE); // Use the default VarResolver to resolve any variables in the annotation fields. VarResolverSession vs = VarResolver.DEFAULT.createSession(); // Apply any settings found on the annotations. WriterSerializer s = JsonSerializer .create() .applyAnnotations(al, vs) .build();
    
    Overrides:
    
    applyAnnotations in class BeanTraverseBuilder
    
    Parameters:
    
    al - The list of all annotations annotated with PropertyStoreApply.
    
    r - The string resolver for resolving variables in annotation values.
    
    Returns:
    
    This object (for method chaining).
  - debug
```
public JsonSchemaGeneratorBuilder debug()
```
    Description copied from class: ContextBuilder
    Context configuration property: Debug mode.
    Enables the following additional information during serialization:
    - When bean getters throws exceptions, the exception includes the object stack information in order to determine how that method was invoked.
    - Enables BeanTraverseContext.BEANTRAVERSE_detectRecursions.
    Enables the following additional information during parsing:
    - When bean setters throws exceptions, the exception includes the object stack information in order to determine how that method was invoked.
    Example:
    
    // Create a serializer with debug enabled. WriterSerializer s = JsonSerializer .create() .debug() .build(); // Same, but use property. WriterSerializer s = JsonSerializer .create() .set(BEAN_debug, true) .build(); // Create a POJO model with a recursive loop. public class A { public Object f; } A a = new A(); a.f = a; // Throws a SerializeException and not a StackOverflowError String json = s.serialize(a);
    - Context.CONTEXT_debug
    Overrides:
    
    debug in class BeanTraverseBuilder
    
    Returns:
    
    This object (for method chaining).
  - locale
```
public JsonSchemaGeneratorBuilder locale(Locale value)
```
    Description copied from class: ContextBuilder
    Context configuration property: Locale.
    Specifies the default locale for serializer and parser sessions when not specified via SessionArgs.locale(Locale). Typically used for POJO swaps that need to deal with locales such as swaps that convert Date and Calendar objects to strings by accessing it via the session passed into the PojoSwap.swap(BeanSession, Object) and PojoSwap.unswap(BeanSession, Object, ClassMeta, String) methods.
    Example:
    
    // Define a POJO swap that skips serializing beans if we're in the UK. public class MyBeanSwap extends StringSwap<MyBean> { @Override public String swap(BeanSession session, MyBean o) throws Exception { if (session.getLocale().equals(Locale.UK)) return null; return o.toString(); } } // Create a serializer that uses the specified locale if it's not passed in through session args. WriterSerializer s = JsonSerializer .create() .locale(Locale.UK) .pojoSwaps(MyBeanSwap.class) .build(); // Same, but use property. WriterSerializer s = JsonSerializer .create() .set(CONTEXT_locale, Locale.UK) .addTo(BEAN_pojoSwaps, MyBeanSwap.class) .build(); // Define on session-args instead. SerializerSessionArgs sessionArgs = new SerializerSessionArgs().locale(Locale.UK); try (WriterSerializerSession session = s.createSession(sessionArgs)) { // Produces "null" if in the UK. String json = s.serialize(new MyBean()); }
    - Context.CONTEXT_locale
    Overrides:
    
    locale in class BeanTraverseBuilder
    
    Parameters:
    
    value - The new value for this property.
    
    Returns:
    
    This object (for method chaining).
  - mediaType
```
public JsonSchemaGeneratorBuilder mediaType(MediaType value)
```
    Description copied from class: ContextBuilder
    Context configuration property: Media type.
    Specifies the default media type for serializer and parser sessions when not specified via SessionArgs.mediaType(MediaType). Typically used for POJO swaps that need to serialize the same POJO classes differently depending on the specific requested media type. For example, a swap could handle a request for media types "application/json" and "application/json+foo" slightly differently even though they're both being handled by the same JSON serializer or parser.
    Example:
    
    // Define a POJO swap that skips serializing beans if the media type is application/json. public class MyBeanSwap extends StringSwap<MyBean> { @Override public String swap(BeanSession session, MyBean o) throws Exception { if (session.getMediaType().equals("application/json")) return null; return o.toString(); } } // Create a serializer that uses the specified media type if it's not passed in through session args. WriterSerializer s = JsonSerializer .create() .mediaType(MediaType.JSON) .build(); // Same, but use property. WriterSerializer s = JsonSerializer .create() .set(CONTEXT_mediaType, MediaType.JSON) .build(); // Define on session-args instead. SerializerSessionArgs sessionArgs = new SerializerSessionArgs().mediaType(MediaType.JSON); try (WriterSerializerSession session = s.createSession(sessionArgs)) { // Produces "null" since it's JSON. String json = s.serialize(new MyBean()); }
    - Context.CONTEXT_mediaType
    Overrides:
    
    mediaType in class BeanTraverseBuilder
    
    Parameters:
    
    value - The new value for this property.
    
    Returns:
    
    This object (for method chaining).
  - prependTo
```
public JsonSchemaGeneratorBuilder prependTo(String name,
                                            Object value)
```
    Description copied from class: ContextBuilder
    Adds a free-form value to the beginning of a LIST property.
    LIST properties are those properties with one of the following type parts:
    - "ls" - Linkedlist<String>
    - "li" - Linkedlist<Integer>
    - "lc" - Linkedlist<Class>
    - "lo" - Linkedlist<Object>
    For example, the BeanContext.BEAN_swaps property which has the value "BeanContext.swaps.lo".
    Example:
    
    // Create a serializer that converts Temporal objects to Basic ISO date strings. WriterSerializer s = JsonSerializer .create() .swaps(TemoralCalendarSwap.BasicIsoDate.class) .build(); // Same, but use generic prependTo() method. WriterSerializer s = JsonSerializer .create() .prependTo(BEAN_swaps, TemoralCalendarSwap.BasicIsoDate.class) .build();
    - PropertyStore
    - ContextBuilder.set(String, Object)
    Overrides:
    
    prependTo in class BeanTraverseBuilder
    
    Parameters:
    
    name - The property name.
    value - The new value to add to the LIST property.
    The valid value types depend on the property type:
    
    "ls" - Any Object converted to a String using value.toString().
    "li" - Any Object converted to an Integer using Integer.valueOf(value.toString()).
    "lc" - Only Class objects are allowed.
    "lo" - Left as-is.
    Returns:
    
    This object (for method chaining).
  - putAllTo
```
public JsonSchemaGeneratorBuilder putAllTo(String name,
                                           Object value)
```
    Description copied from class: ContextBuilder
    Adds or overwrites multiple free-form entries in a MAP property.
    MAP properties are those properties with one of the following type parts:
    - "sms" - TreeMap<String,String>
    - "smi" - TreeMap<String,Integer>
    - "smc" - TreeMap<String,Class>
    - "smo" - TreeMap<String,Object>
    - "oms" - LinkedHashMap<String,String>
    - "omi" - LinkedHashMap<String,Integer>
    - "omc" - LinkedHashMap<String,Class>
    - "omo" - LinkedHashMap<String,Object>
    For example, the BeanContext.BEAN_implClasses property which has the value "BeanContext.implClasses.smc".
    Example:
    
    // Create a serializer that specifies the concrete implementation class for an interface. WriterSerializer s = JsonSerializer .create() .implClass(MyInterface.class, MyImplementation.class) .build(); // Same, but use generic putAllTo() method. WriterSerializer s = JsonSerializer .create() .putAllTo(BEAN_implClasses, AMap.of(MyInterface.class.getName(), MyImplementation.class) ) .build();
    - PropertyStore
    - ContextBuilder.set(String, Object)
    Overrides:
    
    putAllTo in class BeanTraverseBuilder
    
    Parameters:
    
    name - The property name.
    value - Either a JSON Object string or a Map whose valid value types depend on the property type:
    
    "sms","oms" - Any Object converted to a String using value.toString().
    "smi","omi" - Any Object converted to an Integer using Integer.valueOf(value.toString()).
    "smc","omc" - Only Class objects are allowed.
    "smo","omo" - Left as-is.
    Returns:
    
    This object (for method chaining).
  - putTo
```
public JsonSchemaGeneratorBuilder putTo(String name,
                                        String key,
                                        Object value)
```
    Description copied from class: ContextBuilder
    Adds or overwrites a free-form entry in a MAP property.
    MAP properties are those properties with one of the following type parts:
    - "sms" - TreeMap<String,String>
    - "smi" - TreeMap<String,Integer>
    - "smc" - TreeMap<String,Class>
    - "smo" - TreeMap<String,Object>
    - "oms" - LinkedHashMap<String,String>
    - "omi" - LinkedHashMap<String,Integer>
    - "omc" - LinkedHashMap<String,Class>
    - "omo" - LinkedHashMap<String,Object>
    For example, the BeanContext.BEAN_implClasses property which has the value "BeanContext.implClasses.smc".
    Example:
    
    // Create a serializer that specifies the concrete implementation class for an interface. WriterSerializer s = JsonSerializer .create() .implClass(MyInterface.class, MyImplementation.class) .build(); // Same, but use generic putTo() method. WriterSerializer s = JsonSerializer .create() .putTo(BEAN_implClasses, MyInterface.class.getName(), MyImplementation.class) .build();
    - PropertyStore
    - ContextBuilder.set(String, Object)
    Overrides:
    
    putTo in class BeanTraverseBuilder
    
    Parameters:
    
    name - The property name.
    
    key - The property value map key.
    value - The property value map value.
    The valid value types depend on the property type:
    
    "sms","oms" - Any Object converted to a String using value.toString().
    "smi","omi" - Any Object converted to an Integer using Integer.valueOf(value.toString()).
    "smc","omc" - Only Class objects are allowed.
    "smo","omo" - Left as-is.
    Returns:
    
    This object (for method chaining).
  - removeFrom
```
public JsonSchemaGeneratorBuilder removeFrom(String name,
                                             Object value)
```
    Description copied from class: ContextBuilder
    Removes a free-form value from a SET, LIST, or MAP property.
    Example:
    
    // Create a serializer that specifies the concrete implementation class for an interface. WriterSerializer s = JsonSerializer .create() .swaps(TemoralCalendarSwap.BasicIsoDate.class) .build(); // Clone the previous serializer but remove the swap. s = s .builder() .removeFrom(BEAN_swaps, TemoralCalendarSwap.BasicIsoDate.class) .build();
    - PropertyStore
    - ContextBuilder.set(String, Object)
    Overrides:
    
    removeFrom in class BeanTraverseBuilder
    
    Parameters:
    
    name - The property name.
    
    value - The property value in the SET/LIST/MAP property.
    
    Returns:
    
    This object (for method chaining).
  - set
```
public JsonSchemaGeneratorBuilder set(Map<String,Object> properties)
```
    Description copied from class: ContextBuilder
    Sets multiple free-form configuration properties on this object replacing all previous values.
    Identical in function to ContextBuilder.set(String, Object) but allows you to specify multiple values at once.
    Example:
    
    // Create a serializer that sorts maps and bean properties. WriterSerializer s = JsonSerializer .create() .sortMaps() .sortProperties() .build(); // Same, but use generic set(Map) method. WriterSerializer s = JsonSerializer .create() .set( AMap.of( BEAN_sortMaps, true, BEAN_sortProperties, true ) ) .build();
    - PropertyStore
    - ContextBuilder.set(String, Object)
    Overrides:
    
    set in class BeanTraverseBuilder
    
    Parameters:
    properties - The properties to set on this class.
    The keys must be strings.
    The valid value types depend on the property type:
    
    "s" - Any Object converted to a String using value.toString().
    "b" - Any Object converted to a Boolean using Boolean.parseBoolean(value.toString()).
    "i" - Any Object converted to an Integer using Integer.valueOf(value.toString()).
    "c" - Only Class objects are allowed.
    "o" - Left as-is.
    "ss","si","sc" - Any collection or array of any convertible Objects or a JSON Array string.
    "ls","li","lc","lo" - Any collection or array of any convertible Objects or a JSON Array string.
    "sms","smi","smc","smo" - Any sorted map of any convertible Objects or a JSON Object string.
    "oms","omi","omc","omo" - Any ordered map of any convertible Objects or a JSON Object string.
    Returns:
    
    This object (for method chaining).
  - set
```
public JsonSchemaGeneratorBuilder set(String name,
                                      Object value)
```
    Description copied from class: ContextBuilder
    Sets a free-form configuration property on this object.
    Provides the ability to specify configuration property values in a generic fashion.
    Property names must have the following format that identify their datatype...
    "{class}.{name}.{type}"
    
    ...where the parts consist of the following...
    - "{class}" - The group name of the property (e.g. "JsonSerializer").
      It's always going to be the simple class name of the class it's associated with.
    - "{name}" - The property name (e.g. "useWhitespace").
    - "{type}" - The property data type.
      A 1 or 2 character string that identifies the data type of the property.
      Valid values are:
      
      "s" - String
      "b" - Boolean
      "i" - Integer
      "c" - Class
      "o" - Object
      "ss" - TreeSet<String>
      "si" - TreeSet<Integer>
      "sc" - TreeSet<Class>
      "ls" - Linkedlist<String>
      "li" - Linkedlist<Integer>
      "lc" - Linkedlist<Class>
      "lo" - Linkedlist<Object>
      "sms" - TreeMap<String,String>
      "smi" - TreeMap<String,Integer>
      "smc" - TreeMap<String,Class>
      "smo" - TreeMap<String,Object>
      "oms" - LinkedHashMap<String,String>
      "omi" - LinkedHashMap<String,Integer>
      "omc" - LinkedHashMap<String,Class>
      "omo" - LinkedHashMap<String,Object>
    For example, "BeanContext.swaps.lc" refers to a property on the BeanContext class called swaps that has a data type of List<Class>.
    Property values get 'normalized' when they get set. For example, calling set("BeanContext.debug.b", "true") will cause the property value to be converted to a boolean. This allows the underlying PropertyStore class to be comparable and useful in determining whether a cached instance of a context object can be returned.
    Example:
    
    // Create a serializer that sorts maps and bean properties. WriterSerializer s = JsonSerializer .create() .sortMaps() .sortProperties() .build(); // Same, but use generic set() method. WriterSerializer s = JsonSerializer .create() .set(BEAN_sortMaps, true) .set(BEAN_sortProperties, true) .build();
    
    As a general rule, builders don't typically have "unsetter" methods. For example, once you've set strict mode on the ParserBuilder class, a method does not exist for unsetting it. This method can be used in these rare cases where you need to unset a value by setting it to null.
    Example:
    
    // Clone an existing serializer and unset the sort settings. s = s.builder() .set(BEAN_sortMaps, null) .set(BEAN_sortProperties, null) .build();
    - PropertyStore
    Overrides:
    
    set in class BeanTraverseBuilder
    
    Parameters:
    
    name - The property name.
    value - The property value.
    The valid value types depend on the property type:
    
    "s" - Any Object converted to a String using value.toString().
    "b" - Any Object converted to a Boolean using Boolean.parseBoolean(value.toString()).
    "i" - Any Object converted to an Integer using Integer.valueOf(value.toString()).
    "c" - Only Class objects are allowed.
    "o" - Left as-is.
    "ss","si","sc" - Any collection or array of any convertible Objects or a JSON Array string.
    "ls","li","lc","lo" - Any collection or array of any convertible Objects or a JSON Array string.
    "sms","smi","smc","smo" - Any sorted map of any convertible Objects or a JSON Object string.
    "oms","omi","omc","omo" - Any ordered map of any convertible Objects or a JSON Object string.
    Returns:
    
    This object (for method chaining).
  - timeZone
```
public JsonSchemaGeneratorBuilder timeZone(TimeZone value)
```
    Description copied from class: ContextBuilder
    Context configuration property: TimeZone.
    Specifies the default time zone for serializer and parser sessions when not specified via SessionArgs.timeZone(TimeZone). Typically used for POJO swaps that need to deal with timezones such as swaps that convert Date and Calendar objects to strings by accessing it via the session passed into the PojoSwap.swap(BeanSession, Object) and PojoSwap.unswap(BeanSession, Object, ClassMeta, String) methods.
    Example:
    
    // Define a POJO swap that skips serializing beans if the time zone is GMT. public class MyBeanSwap extends StringSwap<MyBean> { @Override public String swap(BeanSession session, MyBean o) throws Exception { if (session.getTimeZone().equals(TimeZone.GMT)) return null; return o.toString(); } } // Create a serializer that uses GMT if the timezone is not specified in the session args. WriterSerializer s = JsonSerializer .create() .timeZone(TimeZone.GMT) .build(); // Same, but use property. WriterSerializer s = JsonSerializer .create() .set(CONTEXT_timeZone, TimeZone.GMT) .build(); // Define on session-args instead. SerializerSessionArgs sessionArgs = new SerializerSessionArgs().timeZone(TimeZone.GMT); try (WriterSerializerSession ss = JsonSerializer.DEFAULT.createSession(sessionArgs)) { // Produces "null" since the time zone is GMT. String json = s.serialize(new MyBean()); }
    - Context.CONTEXT_timeZone
    Overrides:
    
    timeZone in class BeanTraverseBuilder
    
    Parameters:
    
    value - The new value for this property.
    
    Returns:
    
    This object (for method chaining).
  - annotations
```
public JsonSchemaGeneratorBuilder annotations(Annotation... values)
```
    Description copied from class: BeanContextBuilder
    BeanContext configuration property: Dynamically applied POJO annotations.
    Defines annotations to apply to specific classes and methods.
    Allows you to dynamically apply Juneau annotations typically applied directly to classes and methods. Useful in cases where you want to use the functionality of the annotation on beans and bean properties but do not have access to the code to do so.
    As a rule, any Juneau annotation with an on() method can be used with this property.
    The following example shows the equivalent methods for applying the @Bean annotation:
    // Class with explicit annotation. @Bean(bpi="street,city,state") public class A {...} // Class with annotation applied via @BeanConfig public class B {...} // Java REST method with @BeanConfig annotation. @RestMethod(...) @BeanConfig( annotations={ @Bean(on="B", bpi="street,city,state") } ) public void doFoo() {...}
    
    In general, the underlying framework uses this method when it finds dynamically applied annotations on config annotations. However, concrete implementations of annotations are also provided that can be passed directly into builder classes like so:
    // Create a concrete @Bean annotation. BeanAnnotation a = new BeanAnnotation("B").bpi("street,city,state"); // Apply it to a serializer. WriterSerializer ws = JsonSerializer.create().annotations(a).build(); // Serialize a bean with the dynamically applied annotation. String json = ws.serialize(new B());
    
    The following is the list of concrete annotations provided that can be constructed and passed into the builder class:
    The syntax for the on() pattern match parameter depends on whether it applies to a class, method, field, or constructor. The valid pattern matches are:
    - Classes:
      
      Fully qualified:
      
      "com.foo.MyClass"
      
      Fully qualified inner class:
      
      "com.foo.MyClass$Inner1$Inner2"
      
      Simple:
      
      "MyClass"
      
      Simple inner:
      
      "MyClass$Inner1$Inner2"
      "Inner1$Inner2"
      "Inner2"
    - Methods:
      
      Fully qualified with args:
      
      "com.foo.MyClass.myMethod(String,int)"
      "com.foo.MyClass.myMethod(java.lang.String,int)"
      "com.foo.MyClass.myMethod()"
      
      Fully qualified:
      
      "com.foo.MyClass.myMethod"
      
      Simple with args:
      
      "MyClass.myMethod(String,int)"
      "MyClass.myMethod(java.lang.String,int)"
      "MyClass.myMethod()"
      
      Simple:
      
      "MyClass.myMethod"
      
      Simple inner class:
      
      "MyClass$Inner1$Inner2.myMethod"
      "Inner1$Inner2.myMethod"
      "Inner2.myMethod"
    - Fields:
      
      Fully qualified:
      
      "com.foo.MyClass.myField"
      
      Simple:
      
      "MyClass.myField"
      
      Simple inner class:
      
      "MyClass$Inner1$Inner2.myField"
      "Inner1$Inner2.myField"
      "Inner2.myField"
    - Constructors:
      
      Fully qualified with args:
      
      "com.foo.MyClass(String,int)"
      "com.foo.MyClass(java.lang.String,int)"
      "com.foo.MyClass()"
      
      Simple with args:
      
      "MyClass(String,int)"
      "MyClass(java.lang.String,int)"
      "MyClass()"
      
      Simple inner class:
      
      "MyClass$Inner1$Inner2()"
      "Inner1$Inner2()"
      "Inner2()"
    - A comma-delimited list of anything on this list.
    - BeanContext.BEAN_annotations
    Overrides:
    
    annotations in class BeanTraverseBuilder
    
    Parameters:
    
    values - The values to add to this property.
    
    Returns:
    
    This object (for method chaining).
  - beanClassVisibility
```
public JsonSchemaGeneratorBuilder beanClassVisibility(Visibility value)
```
    Description copied from class: BeanContextBuilder
    BeanContext configuration property: Minimum bean class visibility.
    Classes are not considered beans unless they meet the minimum visibility requirements. For example, if the visibility is PUBLIC and the bean class is protected, then the class will not be interpreted as a bean class and be serialized as a string. Use this setting to reduce the visibility requirement.
    Example:
    
    // A bean with a protected class and one field. protected class MyBean { public String foo = "bar"; } // Create a serializer that's capable of serializing the class. WriterSerializer s = JsonSerializer .create() .beanClassVisibility(PROTECTED) .build(); // Same, but use property. WriterSerializer s = JsonSerializer .create() .set(BEAN_beanClassVisibility, "PROTECTED") .build(); // Produces: {"foo","bar"} String json = w.serialize(new MyBean());
    - The @Bean annotation can be used on a non-public bean class to override this setting.
    - The @BeanIgnore annotation can also be used on a public bean class to ignore it as a bean.
    - BeanContext.BEAN_beanClassVisibility
    Overrides:
    
    beanClassVisibility in class BeanTraverseBuilder
    
    Parameters:
    
    value - The new value for this property.
    The default is Visibility.PUBLIC.
    
    Returns:
    
    This object (for method chaining).
  - beanConstructorVisibility
```
public JsonSchemaGeneratorBuilder beanConstructorVisibility(Visibility value)
```
    Description copied from class: BeanContextBuilder
    BeanContext configuration property: Minimum bean constructor visibility.
    Only look for constructors with the specified minimum visibility.
    This setting affects the logic for finding no-arg constructors for bean. Normally, only public no-arg constructors are used. Use this setting if you want to reduce the visibility requirement.
    Example:
    
    // A bean with a protected constructor and one field. public class MyBean { public String foo; protected MyBean() {} } // Create a parser capable of calling the protected constructor. ReaderParser p = ReaderParser .create() .beanConstructorVisibility(PROTECTED) .build(); // Same, but use property. ReaderParser p = JsonParser .create() .set(BEAN_beanConstructorVisibility, "PROTECTED") .build(); // Use it. MyBean c = r.parse("{foo:'bar'}", MyBean.class);
    - The @Beanc annotation can also be used to expose a non-public constructor.
    - The @BeanIgnore annotation can also be used on a public bean constructor to ignore it.
    - BeanContext.BEAN_beanConstructorVisibility
    Overrides:
    
    beanConstructorVisibility in class BeanTraverseBuilder
    
    Parameters:
    
    value - The new value for this property.
    The default is Visibility.PUBLIC.
    
    Returns:
    
    This object (for method chaining).
  - beanFieldVisibility
```
public JsonSchemaGeneratorBuilder beanFieldVisibility(Visibility value)
```
    Description copied from class: BeanContextBuilder
    BeanContext configuration property: Minimum bean field visibility.
    Only look for bean fields with the specified minimum visibility.
    This affects which fields on a bean class are considered bean properties. Normally only public fields are considered. Use this setting if you want to reduce the visibility requirement.
    Example:
    
    // A bean with a protected field. public class MyBean { protected String foo = "bar"; } // Create a serializer that recognizes the protected field. WriterSerializer s = JsonSerializer .create() .beanFieldVisibility(PROTECTED) .build(); // Same, but use property. WriterSerializer s = JsonSerializer .create() .set(BEAN_beanFieldVisibility, "PROTECTED") .build(); // Produces: {"foo":"bar"} String json = s.serialize(new MyBean());
    
    Bean fields can be ignored as properties entirely by setting the value to Visibility.NONE
    // Disable using fields as properties entirely. WriterSerializer s = JsonSerializer .create() .beanFieldVisibility(NONE) .build();
    - The @Beanp annotation can also be used to expose a non-public field.
    - The @BeanIgnore annotation can also be used on a public bean field to ignore it as a bean property.
    - BeanContext.BEAN_beanFieldVisibility
    Overrides:
    
    beanFieldVisibility in class BeanTraverseBuilder
    
    Parameters:
    
    value - The new value for this property.
    The default is Visibility.PUBLIC.
    
    Returns:
    
    This object (for method chaining).
  - beanInterceptor
```
public JsonSchemaGeneratorBuilder beanInterceptor(Class<?> on,
                                                  Class<? extends BeanInterceptor<?>> value)
```
    Description copied from class: BeanContextBuilder
    Bean interceptor.
    Bean interceptors can be used to intercept calls to getters and setters and alter their values in transit.
    Example:
    
    // Interceptor that strips out sensitive information. public class AddressInterceptor extends BeanInterceptor<Address> { public Object readProperty(Address bean, String name, Object value) { if ("taxInfo".equals(name)) return "redacted"; return value; } public Object writeProperty(Address bean, String name, Object value) { if ("taxInfo".equals(name) && "redacted".equals(value)) return TaxInfoUtils.lookup(bean.getStreet(), bean.getCity(), bean.getState()); return value; } } // Our bean class. public class Address { public String getTaxInfo() {...} public void setTaxInfo(String s) {...} } // Register filter on serializer or parser. WriterSerializer s = JsonSerializer .create() .beanInterceptor(Address.class, AddressInterceptor.class) .build(); // Produces: {"taxInfo":"redacted"} String json = s.serialize(new Address());
    - BeanInterceptor
    - Bean(interceptor)
    Overrides:
    
    beanInterceptor in class BeanTraverseBuilder
    
    Parameters:
    
    on - The bean that the filter applies to.
    
    value - The new value for this property.
    
    Returns:
    
    This object (for method chaining).
  - beanMapPutReturnsOldValue
```
public JsonSchemaGeneratorBuilder beanMapPutReturnsOldValue()
```
    Description copied from class: BeanContextBuilder
    BeanContext configuration property: BeanMap.put() returns old property value.
    When enabled, then the BeanMap.put() method will return old property values. Otherwise, it returns null.
    Disabled by default because it introduces a slight performance penalty during serialization.
    Example:
    
    // Create a serializer that creates BeanMaps with normal put() behavior. WriterSerializer s = JsonSerializer .create() .beanMapPutReturnsOldValue() .build(); // Same, but use property. WriterSerializer s = JsonSerializer .create() .set(BEAN_beanMapPutReturnsOldValue, true) .build(); BeanMap<MyBean> bm = s.createSession().toBeanMap(new MyBean()); bm.put("foo", "bar"); Object oldValue = bm.put("foo", "baz"); // oldValue == "bar"
    - BeanContext.BEAN_beanMapPutReturnsOldValue
    Overrides:
    
    beanMapPutReturnsOldValue in class BeanTraverseBuilder
    
    Returns:
    
    This object (for method chaining).
  - beanMethodVisibility
```
public JsonSchemaGeneratorBuilder beanMethodVisibility(Visibility value)
```
    Description copied from class: BeanContextBuilder
    BeanContext configuration property: Minimum bean method visibility.
    Only look for bean methods with the specified minimum visibility.
    This affects which methods are detected as getters and setters on a bean class. Normally only public getters and setters are considered. Use this setting if you want to reduce the visibility requirement.
    Example:
    
    // A bean with a protected getter. public class MyBean { public String getFoo() { return "foo"; } protected String getBar() { return "bar"; } } // Create a serializer that looks for protected getters and setters. WriterSerializer s = JsonSerializer .create() .beanMethodVisibility(PROTECTED) .build(); // Same, but use property. WriterSerializer s = JsonSerializer .create() .set(BEAN_beanMethodVisibility, "PROTECTED") .build(); // Produces: {"foo":"foo","bar":"bar"} String json = s.serialize(new MyBean());
    - The @Beanp annotation can also be used to expose a non-public method.
    - The @BeanIgnore annotation can also be used on a public bean getter/setter to ignore it as a bean property.
    - BeanContext.BEAN_beanMethodVisibility
    Overrides:
    
    beanMethodVisibility in class BeanTraverseBuilder
    
    Parameters:
    
    value - The new value for this property.
    The default is Visibility.PUBLIC
    
    Returns:
    
    This object (for method chaining).
  - beansDontRequireSomeProperties
```
public JsonSchemaGeneratorBuilder beansDontRequireSomeProperties()
```
    Description copied from class: BeanContextBuilder
    BeanContext configuration property: Beans require at least one property.
    When enabled, then a Java class must contain at least 1 property to be considered a bean. Otherwise, the bean will be serialized as a string using the Object.toString() method.
    The @Bean annotation can be used on a class to override this setting when true.
    Example:
    
    // A bean with no properties. public class MyBean { } // Create a serializer that serializes beans even if they have zero properties. WriterSerializer s = JsonSerializer .create() .beansDontRequireSomeProperties() .build(); // Same, but use property. WriterSerializer s = JsonSerializer .create() .set(BEAN_beansRequireSomeProperties, false) .build(); // Produces: {} String json = s.serialize(new MyBean());
    - The @Bean annotation can be used on the class to force it to be recognized as a bean class even if it has no properties.
    - BeanContext.BEAN_beansRequireSomeProperties
    Overrides:
    
    beansDontRequireSomeProperties in class BeanTraverseBuilder
    
    Returns:
    
    This object (for method chaining).
  - beansRequireDefaultConstructor
```
public JsonSchemaGeneratorBuilder beansRequireDefaultConstructor()
```
    Description copied from class: BeanContextBuilder
    BeanContext configuration property: Beans require no-arg constructors.
    When enabled, a Java class must implement a default no-arg constructor to be considered a bean. Otherwise, the bean will be serialized as a string using the Object.toString() method.
    Example:
    
    // A bean without a no-arg constructor. public class MyBean { // A property method. public String foo = "bar"; // A no-arg constructor public MyBean(String foo) { this.foo = foo; } @Override public String toString() { return "bar"; } } // Create a serializer that ignores beans without default constructors. WriterSerializer s = JsonSerializer .create() .beansRequireDefaultConstructor() .build(); // Same, but use property. WriterSerializer s = JsonSerializer .create() .set(BEAN_beansRequireDefaultConstructor, true) .build(); // Produces: "bar" String json = s.serialize(new MyBean());
    - The @Bean annotation can be used on a bean class to override this setting.
    - The @BeanIgnore annotation can also be used on a class to ignore it as a bean.
    - BeanContext.BEAN_beansRequireDefaultConstructor
    Overrides:
    
    beansRequireDefaultConstructor in class BeanTraverseBuilder
    
    Returns:
    
    This object (for method chaining).
  - beansRequireSerializable
```
public JsonSchemaGeneratorBuilder beansRequireSerializable()
```
    Description copied from class: BeanContextBuilder
    BeanContext configuration property: Beans require Serializable interface.
    When enabled, a Java class must implement the Serializable interface to be considered a bean. Otherwise, the bean will be serialized as a string using the Object.toString() method.
    Example:
    
    // A bean without a Serializable interface. public class MyBean { // A property method. public String foo = "bar"; @Override public String toString() { return "bar"; } } // Create a serializer that ignores beans not implementing Serializable. WriterSerializer s = JsonSerializer .create() .beansRequireSerializable() .build(); // Same, but use property. WriterSerializer s = JsonSerializer .create() .set(BEAN_beansRequireSerializable, true) .build(); // Produces: "bar" String json = s.serialize(new MyBean());
    - The @Bean annotation can be used on a bean class to override this setting.
    - The @BeanIgnore annotation can also be used on a class to ignore it as a bean.
    - BeanContext.BEAN_beansRequireSerializable
    Overrides:
    
    beansRequireSerializable in class BeanTraverseBuilder
    
    Returns:
    
    This object (for method chaining).
  - beansRequireSettersForGetters
```
public JsonSchemaGeneratorBuilder beansRequireSettersForGetters()
```
    Description copied from class: BeanContextBuilder
    BeanContext configuration property: Beans require setters for getters.
    When enabled, ignore read-only properties (properties with getters but not setters).
    Example:
    
    // A bean without a Serializable interface. public class MyBean { // A read/write property. public String getFoo() { return "foo"; } public void setFoo(String foo) { ... } // A read-only property. public String getBar() { return "bar"; } } // Create a serializer that ignores bean properties without setters. WriterSerializer s = JsonSerializer .create() .beansRequireSettersForGetters() .build(); // Same, but use property. WriterSerializer s = JsonSerializer .create() .set(BEAN_beansRequireSettersForGetters, true) .build(); // Produces: {"foo":"foo"} String json = s.serialize(new MyBean());
    - The @Beanp annotation can be used on the getter to override this setting.
    - The @BeanIgnore annotation can also be used on getters to ignore them as bean properties.
    - BeanContext.BEAN_beansRequireSettersForGetters
    Overrides:
    
    beansRequireSettersForGetters in class BeanTraverseBuilder
    
    Returns:
    
    This object (for method chaining).
  - bpi
```
public JsonSchemaGeneratorBuilder bpi(Map<String,Object> values)
```
    Description copied from class: BeanContextBuilder
    Bean property includes.
    Specifies the set and order of names of properties associated with bean classes.
    For example, bpi(AMap.of("MyBean", "foo,bar")) means only serialize the foo and bar properties on the specified bean. Likewise, parsing will ignore any bean properties not specified and either throw an exception or silently ignore them depending on whether BeanContextBuilder.ignoreUnknownBeanProperties() has been called.
    This value is entirely optional if you simply want to expose all the getters and public fields on a class as bean properties. However, it's useful if you want certain getters to be ignored or you want the properties to be serialized in a particular order. Note that on IBM JREs, the property order is the same as the order in the source code, whereas on Oracle JREs, the order is entirely random.
    Setting applies to specified class and all subclasses.
    Example:
    
    // A bean with 3 properties. public class MyBean { public String foo = "foo", bar = "bar", baz = "baz"; } // Create a serializer that includes only the 'foo' and 'bar' properties on the MyBean class. WriterSerializer s = JsonSerializer .create() .bpi(AMap.of("MyBean", "foo,bar")) .build(); // Produces: {"foo":"foo","bar":"bar"} String json = s.serialize(new MyBean());
    
    This method is functionally equivalent to the following code for each entry:
    builder.annotations(new BeanAnnotation(key).bpi(value.toString()));
    - Bean.bpi() - On an annotation on the bean class itself.
    - BeanConfig.bpi() - On a bean config annotation (see BeanContextBuilder.annotations(Annotation...)).
    Overrides:
    
    bpi in class BeanTraverseBuilder
    
    Parameters:
    
    values - The values to add to this builder.
    Keys are bean class names which can be a simple name, fully-qualified name, or "*" for all beans.
    Values are comma-delimited lists of property names. Non-String objects are first converted to Strings.
    
    Returns:
    
    This object (for method chaining).
  - bpi
```
public JsonSchemaGeneratorBuilder bpi(Class<?> beanClass,
                                      String properties)
```
    Description copied from class: BeanContextBuilder
    Bean property includes.
    Specifies the set and order of names of properties associated with the bean class.
    For example, bpi(MyBean.class, "foo,bar") means only serialize the foo and bar properties on the specified bean. Likewise, parsing will ignore any bean properties not specified and either throw an exception or silently ignore them depending on whether BeanContextBuilder.ignoreUnknownBeanProperties() has been called.
    This value is entirely optional if you simply want to expose all the getters and public fields on a class as bean properties. However, it's useful if you want certain getters to be ignored or you want the properties to be serialized in a particular order. Note that on IBM JREs, the property order is the same as the order in the source code, whereas on Oracle JREs, the order is entirely random.
    Setting applies to specified class and all subclasses.
    Example:
    
    // A bean with 3 properties. public class MyBean { public String foo = "foo", bar = "bar", baz = "baz"; } // Create a serializer that includes only the 'foo' and 'bar' properties on the MyBean class. WriterSerializer s = JsonSerializer .create() .bpi(MyBean.class, "foo,bar") .build(); // Produces: {"foo":"foo","bar":"bar"} String json = s.serialize(new MyBean());
    
    This method is functionally equivalent to the following code:
    builder.annotations(new BeanAnnotation(beanClass.getName()).bpi(properties));
    - Bean.bpi() - On an annotation on the bean class itself.
    - BeanConfig.bpi() - On a bean config annotation (see BeanContextBuilder.annotations(Annotation...)).
    Overrides:
    
    bpi in class BeanTraverseBuilder
    
    Parameters:
    
    beanClass - The bean class.
    
    properties - Comma-delimited list of property names.
    
    Returns:
    
    This object (for method chaining).
  - bpi
```
public JsonSchemaGeneratorBuilder bpi(String beanClassName,
                                      String properties)
```
    Description copied from class: BeanContextBuilder
    Bean property includes.
    Specifies the set and order of names of properties associated with the bean class.
    For example, bpi("MyBean", "foo,bar") means only serialize the foo and bar properties on the specified bean. Likewise, parsing will ignore any bean properties not specified and either throw an exception or silently ignore them depending on whether BeanContextBuilder.ignoreUnknownBeanProperties() has been called.
    This value is entirely optional if you simply want to expose all the getters and public fields on a class as bean properties. However, it's useful if you want certain getters to be ignored or you want the properties to be serialized in a particular order. Note that on IBM JREs, the property order is the same as the order in the source code, whereas on Oracle JREs, the order is entirely random.
    Setting applies to specified class and all subclasses.
    Example:
    
    // A bean with 3 properties. public class MyBean { public String foo = "foo", bar = "bar", baz = "baz"; } // Create a serializer that includes only the 'foo' and 'bar' properties on the MyBean class. WriterSerializer s = JsonSerializer .create() .bpi("MyBean", "foo,bar") .build(); // Produces: {"foo":"foo","bar":"bar"} String json = s.serialize(new MyBean());
    
    This method is functionally equivalent to the following code:
    builder.annotations(new BeanAnnotation(beanClassName).bpi(properties));
    - Bean.bpi() - On an annotation on the bean class itself.
    - BeanConfig.bpi() - On a bean config annotation (see BeanContextBuilder.annotations(Annotation...)).
    Overrides:
    
    bpi in class BeanTraverseBuilder
    
    Parameters:
    
    beanClassName - The bean class name.
    Can be a simple name, fully-qualified name, or "*" for all beans.
    
    properties - Comma-delimited list of property names.
    
    Returns:
    
    This object (for method chaining).
  - bpro
```
public JsonSchemaGeneratorBuilder bpro(Map<String,Object> values)
```
    Description copied from class: BeanContextBuilder
    Read-only bean properties.
    Specifies one or more properties on beans that are read-only despite having valid getters. Serializers will serialize such properties as usual, but parsers will silently ignore them. Note that this is different from the bpi/bpx settings which include or exclude properties for both serializers and parsers.
    Example:
    
    // A bean with 3 properties. public class MyBean { public String foo, bar, baz; } // Create a serializer with read-only property settings. WriterSerializer s = JsonSerializer .create() .bpro(AMap.of("MyBean", "bar,baz")) .build(); // All 3 properties will be serialized. String json = s.serialize(new MyBean()); // Create a parser with read-only property settings. ReaderParser p = JsonParser .create() .bpro(AMap.of("MyBean", "bar,baz")) .ignoreUnknownBeanProperties() .build(); // Parser ignores bar and baz properties. MyBean b = p.parse("{foo:'foo',bar:'bar',baz:'baz'}", MyBean.class);
    
    This method is functionally equivalent to the following code for each entry:
    builder.annotations(new BeanAnnotation(key).bpro(value.toString()));
    - BeanConfig.bpro()
    - Bean.bpro()
    Overrides:
    
    bpro in class BeanTraverseBuilder
    
    Parameters:
    
    values - The values to add to this builder.
    Keys are bean class names which can be a simple name, fully-qualified name, or "*" for all beans.
    Values are comma-delimited lists of property names. Non-String objects are first converted to Strings.
    
    Returns:
    
    This object (for method chaining).
  - bpro
```
public JsonSchemaGeneratorBuilder bpro(Class<?> beanClass,
                                       String properties)
```
    Description copied from class: BeanContextBuilder
    Read-only bean properties.
    Specifies one or more properties on a bean that are read-only despite having valid getters. Serializers will serialize such properties as usual, but parsers will silently ignore them. Note that this is different from the bpi/bpx settings which include or exclude properties for both serializers and parsers.
    Example:
    
    // A bean with 3 properties. public class MyBean { public String foo, bar, baz; } // Create a serializer with read-only property settings. WriterSerializer s = JsonSerializer .create() .bpro(MyBean.class, "bar,baz") .build(); // All 3 properties will be serialized. String json = s.serialize(new MyBean()); // Create a parser with read-only property settings. ReaderParser p = JsonParser .create() .bpro(MyBean.class, "bar,baz") .ignoreUnknownBeanProperties() .build(); // Parser ignores bar and baz properties. MyBean b = p.parse("{foo:'foo',bar:'bar',baz:'baz'}", MyBean.class);
    
    This method is functionally equivalent to the following code:
    builder.annotations(new BeanAnnotation(beanClass.getName()).bpro(properties));
    - BeanConfig.bpro()
    - Bean.bpro()
    Overrides:
    
    bpro in class BeanTraverseBuilder
    
    Parameters:
    
    beanClass - The bean class.
    
    properties - Comma-delimited list of property names.
    
    Returns:
    
    This object (for method chaining).
  - bpro
```
public JsonSchemaGeneratorBuilder bpro(String beanClassName,
                                       String properties)
```
    Description copied from class: BeanContextBuilder
    Read-only bean properties.
    Specifies one or more properties on a bean that are read-only despite having valid getters. Serializers will serialize such properties as usual, but parsers will silently ignore them. Note that this is different from the bpi/bpx settings which include or exclude properties for both serializers and parsers.
    Example:
    
    // A bean with 3 properties. public class MyBean { public String foo, bar, baz; } // Create a serializer with read-only property settings. WriterSerializer s = JsonSerializer .create() .bpro("MyBean", "bar,baz") .build(); // All 3 properties will be serialized. String json = s.serialize(new MyBean()); // Create a parser with read-only property settings. ReaderParser p = JsonParser .create() .bpro("MyBean", "bar,baz") .ignoreUnknownBeanProperties() .build(); // Parser ignores bar and baz properties. MyBean b = p.parse("{foo:'foo',bar:'bar',baz:'baz'}", MyBean.class);
    
    This method is functionally equivalent to the following code:
    builder.annotations(new BeanAnnotation(beanClass.getName).bpro(properties));
    - BeanConfig.bpro()
    - Bean.bpro()
    Overrides:
    
    bpro in class BeanTraverseBuilder
    
    Parameters:
    
    beanClassName - The bean class name.
    Can be a simple name, fully-qualified name, or "*" for all bean classes.
    
    properties - Comma-delimited list of property names.
    
    Returns:
    
    This object (for method chaining).
  - bpwo
```
public JsonSchemaGeneratorBuilder bpwo(Map<String,Object> values)
```
    Description copied from class: BeanContextBuilder
    Write-only bean properties.
    Specifies one or more properties on a bean that are write-only despite having valid setters. Parsers will parse such properties as usual, but serializers will silently ignore them. Note that this is different from the bpi/bpx settings which include or exclude properties for both serializers and parsers.
    Example:
    
    // A bean with 3 properties. public class MyBean { public String foo, bar, baz; } // Create a serializer with write-only property settings. WriterSerializer s = JsonSerializer .create() .bpwo(AMap.of("MyBean", "bar,baz")) .build(); // Only foo will be serialized. String json = s.serialize(new MyBean()); // Create a parser with write-only property settings. ReaderParser p = JsonParser .create() .bpwo(AMap.of("MyBean", "bar,baz")) .build(); // Parser parses all 3 properties. MyBean b = p.parse("{foo:'foo',bar:'bar',baz:'baz'}", MyBean.class);
    
    This method is functionally equivalent to the following code for each entry:
    builder.annotations(new BeanAnnotation(key).bpwo(value.toString()));
    - BeanConfig.bpwo()
    - Bean.bpwo()
    Overrides:
    
    bpwo in class BeanTraverseBuilder
    
    Parameters:
    
    values - The values to add to this builder.
    Keys are bean class names which can be a simple name, fully-qualified name, or "*" for all beans.
    Values are comma-delimited lists of property names. Non-String objects are first converted to Strings.
    
    Returns:
    
    This object (for method chaining).
  - bpwo
```
public JsonSchemaGeneratorBuilder bpwo(Class<?> beanClass,
                                       String properties)
```
    Description copied from class: BeanContextBuilder
    Write-only bean properties.
    Specifies one or more properties on a bean that are write-only despite having valid setters. Parsers will parse such properties as usual, but serializers will silently ignore them. Note that this is different from the bpi/bpx settings which include or exclude properties for both serializers and parsers.
    Example:
    
    // A bean with 3 properties. public class MyBean { public String foo, bar, baz; } // Create a serializer with write-only property settings. WriterSerializer s = JsonSerializer .create() .bpwo(MyBean.class, "bar,baz") .build(); // Only foo will be serialized. String json = s.serialize(new MyBean()); // Create a parser with write-only property settings. ReaderParser p = JsonParser .create() .bpwo(MyBean.class, "bar,baz") .build(); // Parser parses all 3 properties. MyBean b = p.parse("{foo:'foo',bar:'bar',baz:'baz'}", MyBean.class);
    
    This method is functionally equivalent to the following code:
    builder.annotations(new BeanAnnotation(beanClass.getName).bpwo(properties));
    - BeanConfig.bpwo()
    - Bean.bpwo()
    Overrides:
    
    bpwo in class BeanTraverseBuilder
    
    Parameters:
    
    beanClass - The bean class.
    
    properties - Comma-delimited list of property names.
    
    Returns:
    
    This object (for method chaining).
  - bpwo
```
public JsonSchemaGeneratorBuilder bpwo(String beanClassName,
                                       String properties)
```
    Description copied from class: BeanContextBuilder
    Write-only bean properties.
    Specifies one or more properties on a bean that are write-only despite having valid setters. Parsers will parse such properties as usual, but serializers will silently ignore them. Note that this is different from the bpi/bpx settings which include or exclude properties for both serializers and parsers.
    Example:
    
    // A bean with 3 properties. public class MyBean { public String foo, bar, baz; } // Create a serializer with write-only property settings. WriterSerializer s = JsonSerializer .create() .bpwo("MyBean", "bar,baz") .build(); // Only foo will be serialized. String json = s.serialize(new MyBean()); // Create a parser with write-only property settings. ReaderParser p = JsonParser .create() .bpwo("MyBean", "bar,baz") .build(); // Parser parses all 3 properties. MyBean b = p.parse("{foo:'foo',bar:'bar',baz:'baz'}", MyBean.class);
    
    This method is functionally equivalent to the following code:
    builder.annotations(new BeanAnnotation(beanClassName).bpwo(properties));
    - BeanConfig.bpwo()
    - Bean.bpwo()
    Overrides:
    
    bpwo in class BeanTraverseBuilder
    
    Parameters:
    
    beanClassName - The bean class name.
    Can be a simple name, fully-qualified name, or "*" for all bean classes.
    
    properties - Comma-delimited list of property names.
    
    Returns:
    
    This object (for method chaining).
  - bpx
```
public JsonSchemaGeneratorBuilder bpx(Map<String,Object> values)
```
    Description copied from class: BeanContextBuilder
    Bean property excludes.
    Specifies to exclude the specified list of properties for the specified bean classes.
    Same as BeanContextBuilder.bpi(Map) except you specify a list of bean property names that you want to exclude from serialization.
    Setting applies to specified class and all subclasses.
    Example:
    
    // A bean with 3 properties. public class MyBean { public String foo = "foo", bar = "bar", baz = "baz"; } // Create a serializer that excludes the "bar" and "baz" properties on the MyBean class. WriterSerializer s = JsonSerializer .create() .bpx(AMap.of("MyBean", "bar,baz")) .build(); // Produces: {"foo":"foo"} String json = s.serialize(new MyBean());
    
    This method is functionally equivalent to the following code for each entry:
    builder.annotations(new BeanAnnotation(key).bpx(value.toString()));
    - BeanConfig.bpx()
    - Bean.bpx()
    Overrides:
    
    bpx in class BeanTraverseBuilder
    
    Parameters:
    
    values - The values to add to this builder.
    Keys are bean class names which can be a simple name, fully-qualified name, or "*" for all beans.
    Values are comma-delimited lists of property names. Non-String objects are first converted to Strings.
    
    Returns:
    
    This object (for method chaining).
  - bpx
```
public JsonSchemaGeneratorBuilder bpx(Class<?> beanClass,
                                      String properties)
```
    Description copied from class: BeanContextBuilder
    Bean property excludes.
    Specifies to exclude the specified list of properties for the specified bean class.
    Same as BeanContextBuilder.bpi(Class, String) except you specify a list of bean property names that you want to exclude from serialization.
    Setting applies to specified class and all subclasses.
    Example:
    
    // A bean with 3 properties. public class MyBean { public String foo = "foo", bar = "bar", baz = "baz"; } // Create a serializer that excludes the "bar" and "baz" properties on the MyBean class. WriterSerializer s = JsonSerializer .create() .bpx(MyBean.class, "bar,baz") .build(); // Produces: {"foo":"foo"} String json = s.serialize(new MyBean());
    
    This method is functionally equivalent to the following code:
    builder.annotations(new BeanAnnotation(beanClass.getName()).bpx(properties));
    - BeanConfig.bpx()
    - Bean.bpx()
    Overrides:
    
    bpx in class BeanTraverseBuilder
    
    Parameters:
    
    beanClass - The bean class.
    
    properties - Comma-delimited list of property names.
    
    Returns:
    
    This object (for method chaining).
  - bpx
```
public JsonSchemaGeneratorBuilder bpx(String beanClassName,
                                      String properties)
```
    Description copied from class: BeanContextBuilder
    
    Bean property excludes.
    Specifies to exclude the specified list of properties for the specified bean class.
    Same as BeanContextBuilder.bpx(String, String) except you specify a list of bean property names that you want to exclude from serialization.
    Setting applies to specified class and all subclasses.
    Example:
    
    // A bean with 3 properties. public class MyBean { public String foo = "foo", bar = "bar", baz = "baz"; } // Create a serializer that excludes the "bar" and "baz" properties on the MyBean class. WriterSerializer s = JsonSerializer .create() .bpx("MyBean", "bar,baz") .build(); // Produces: {"foo":"foo"} String json = s.serialize(new MyBean());
    
    This method is functionally equivalent to the following code:
    builder.annotations(new BeanAnnotation(beanClassName).bpx(properties));
    
    Overrides:
    
    bpx in class BeanTraverseBuilder
    
    Parameters:
    
    beanClassName - The bean class name.
    Can be a simple name, fully-qualified name, or "*" for all bean classes.
    
    properties - Comma-delimited list of property names.
    
    Returns:
    
    This object (for method chaining).
  - dictionary
```
public JsonSchemaGeneratorBuilder dictionary(Object... values)
```
    Description copied from class: BeanContextBuilder
    BeanContext configuration property: Bean dictionary.
    The list of classes that make up the bean dictionary in this bean context.
    A dictionary is a name/class mapping used to find class types during parsing when they cannot be inferred through reflection. The names are defined through the @Bean(typeName) annotation defined on the bean class. For example, if a class Foo has a type-name of "myfoo", then it would end up serialized as "{_type:'myfoo',...}" in JSON (depending on addBeanTypes/addRootType properties) or "<myfoo>...</myfoo>" in XML.
    This setting tells the parsers which classes to look for when resolving "_type" attributes.
    Values can consist of any of the following types:
    - Any bean class that specifies a value for @Bean(typeName).
    - Any subclass of BeanDictionaryList containing a collection of bean classes with type name annotations.
    - Any subclass of BeanDictionaryMap containing a mapping of type names to classes without type name annotations.
    - Any array or collection of the objects above.
    Example:
    
    // POJOs with @Bean(name) annotations. @Bean(typeName="foo") public class Foo {...} @Bean(typeName="bar") public class Bar {...} // Create a parser and tell it which classes to try to resolve. ReaderParser p = JsonParser .create() .dictionary(Foo.class, Bar.class) .addBeanTypes() .build(); // Same, but use property. ReaderParser p = JsonParser .create() .addTo(BEAN_beanDictionary, Foo.class) .addTo(BEAN_beanDictionary, Bar.class) .set(SERIALIZER_addBeanTypes, true) .build(); // A bean with a field with an indeterminate type. public class MyBean { public Object mySimpleField; } // Parse bean. MyBean b = p.parse("{mySimpleField:{_type:'foo',...}}", MyBean.class);
    
    Another option is to use the Bean.dictionary() annotation on the POJO class itself:
    // Instead of by parser, define a bean dictionary on a class through an annotation. // This applies to all properties on this class and all subclasses. @Bean(dictionary={Foo.class,Bar.class}) public class MyBean { public Object mySimpleField; // May contain Foo or Bar object. public Map<String,Object> myMapField; // May contain Foo or Bar objects. }
    
    A typical usage is to allow for HTML documents to be parsed back into HTML beans:
    // Use the predefined HTML5 bean dictionary which is a BeanDictionaryList. ReaderParser p = HtmlParser .create() .dictionary(HtmlBeanDictionary.class) .build(); // Parse an HTML body into HTML beans. Body body = p.parse("<body><ul><li>foo</li><li>bar</li></ul>", Body.class);
    - BeanContext.BEAN_beanDictionary
    Overrides:
    
    dictionary in class BeanTraverseBuilder
    
    Parameters:
    
    values - The values to add to this property.
    
    Returns:
    
    This object (for method chaining).
  - dictionaryOn
```
public JsonSchemaGeneratorBuilder dictionaryOn(Class<?> on,
                                               Class<?>... values)
```
    Description copied from class: BeanContextBuilder
    BeanContext configuration property: Bean dictionary.
    This is identical to BeanContextBuilder.dictionary(Object...), but specifies a dictionary within the context of a single class as opposed to globally.
    Example:
    
    // POJOs with @Bean(name) annotations. @Bean(typeName="foo") public class Foo {...} @Bean(typeName="bar") public class Bar {...} // A bean with a field with an indeterminate type. public class MyBean { public Object mySimpleField; } // Create a parser and tell it which classes to try to resolve. ReaderParser p = JsonParser .create() .dictionaryOn(MyBean.class, Foo.class, Bar.class) .build(); // Parse bean. MyBean b = p.parse("{mySimpleField:{_type:'foo',...}}", MyBean.class);
    
    This is functionally equivalent to the Bean.dictionary() annotation.
    - Bean.dictionary()
    - BeanContext.BEAN_beanDictionary
    Overrides:
    
    dictionaryOn in class BeanTraverseBuilder
    
    Parameters:
    
    on - The class that the dictionary values apply to.
    
    values - The new values for this property.
    
    Returns:
    
    This object (for method chaining).
  - dontIgnorePropertiesWithoutSetters
```
public JsonSchemaGeneratorBuilder dontIgnorePropertiesWithoutSetters()
```
    Description copied from class: BeanContextBuilder
    BeanContext configuration property: Ignore properties without setters.
    When enabled, trying to set a value on a bean property without a setter will silently be ignored. Otherwise, a BeanRuntimeException is thrown.
    Example:
    
    // A bean with a property with a getter but not a setter. public class MyBean { public void getFoo() { return "foo"; } } // Create a parser that throws an exception if a setter is not found but a getter is. ReaderParser p = JsonParser .create() .dontIgnorePropertiesWithoutSetters() .build(); // Same, but use property. ReaderParser p = JsonParser .create() .set(BEAN_ignorePropertiesWithoutSetters, false) .build(); // Throws a ParseException. MyBean b = p.parse("{foo:'bar'}", MyBean.class);
    - The @BeanIgnore annotation can also be used on getters and fields to ignore them.
    - BeanContext.BEAN_ignorePropertiesWithoutSetters
    Overrides:
    
    dontIgnorePropertiesWithoutSetters in class BeanTraverseBuilder
    
    Returns:
    
    This object (for method chaining).
  - dontIgnoreTransientFields
```
public JsonSchemaGeneratorBuilder dontIgnoreTransientFields()
```
    Description copied from class: BeanContextBuilder
    BeanContext configuration property: Ignore transient fields.
    When enabled, methods and fields marked as transient will be ignored as bean properties.
    Example:
    
    // A bean with a transient field. public class MyBean { public transient String foo = "foo"; } // Create a parser that doesn't ignore transient fields. ReaderParser p = JsonParser .create() .dontIgnoreTransientFields() .build(); // Same, but use property. ReaderParser p = JsonParser .create() .set(BEAN_ignoreTransientFields, false) .build(); // Produces: {"foo":"foo"} String json = s.serialize(new MyBean());
    - The @Beanp annotation can also be used on transient fields to keep them from being ignored.
    - BeanContext.BEAN_ignoreTransientFields
    Overrides:
    
    dontIgnoreTransientFields in class BeanTraverseBuilder
    
    Returns:
    
    This object (for method chaining).
  - dontIgnoreUnknownNullBeanProperties
```
public JsonSchemaGeneratorBuilder dontIgnoreUnknownNullBeanProperties()
```
    Description copied from class: BeanContextBuilder
    BeanContext configuration property: Ignore unknown properties with null values.
    When enabled, trying to set a null value on a non-existent bean property will silently be ignored. Otherwise, a BeanRuntimeException is thrown.
    Example:
    
    // A bean with a single property. public class MyBean { public String foo; } // Create a parser that throws an exception on an unknown property even if the value being set is null. ReaderParser p = JsonParser .create() .dontIgnoreUnknownNullBeanProperties() .build(); // Same, but use property. ReaderParser p = JsonParser .create() .set(BEAN_ignoreUnknownNullBeanProperties, false) .build(); // Throws a BeanRuntimeException wrapped in a ParseException on the unknown 'bar' property. MyBean b = p.parse("{foo:'foo',bar:null}", MyBean.class);
    - BeanContext.BEAN_ignoreUnknownNullBeanProperties
    Overrides:
    
    dontIgnoreUnknownNullBeanProperties in class BeanTraverseBuilder
    
    Returns:
    
    This object (for method chaining).
  - dontUseInterfaceProxies
```
public JsonSchemaGeneratorBuilder dontUseInterfaceProxies()
```
    Description copied from class: BeanContextBuilder
    BeanContext configuration property: Use interface proxies.
    When enabled, interfaces will be instantiated as proxy classes through the use of an InvocationHandler if there is no other way of instantiating them. Otherwise, throws a BeanRuntimeException.
    Example:
    
    // An interface with a single getter. public interface MyBean { String getFoo(); void setFoo(String foo); } // Create a parser that uses interface proxies. ReaderParser p = JsonParser .create() .build(); // Same, but use property. ReaderParser p = JsonParser .create() .set(BEAN_useInterfaceProxies, true) .build(); // Creates a proxy implementation of a MyBean interface. MyBean b = p.parse("{foo:'bar'}", MyBean.class);
    - BeanContext.BEAN_useInterfaceProxies
    Overrides:
    
    dontUseInterfaceProxies in class BeanTraverseBuilder
    
    Returns:
    
    This object (for method chaining).
  - example
```
public <T> JsonSchemaGeneratorBuilder example(Class<T> pojoClass,
                                              T o)
```
    Description copied from class: BeanContextBuilder
    BeanContext configuration property: POJO example.
    Specifies an example of the specified class.
    Examples are used in cases such as POJO examples in Swagger documents.
    Setting applies to specified class and all subclasses.
    Example:
    
    // Create a serializer that excludes the 'foo' and 'bar' properties on the MyBean class. WriterSerializer s = JsonSerializer .create() .example(MyBean.class, new MyBean().foo("foo").bar(123)) .build(); // Same, but use property. WriterSerializer s = JsonSerializer .create() .addTo(BEAN_examples, MyBean.class.getName(), new MyBean().foo("foo").bar(123)) .build();
    
    POJO examples can also be defined on classes via the following:
    - A static field annotated with @Example.
    - A static method annotated with @Example with zero arguments or one BeanSession argument.
    - A static method with name example with no arguments or one BeanSession argument.
    - BeanContext.BEAN_examples
    Overrides:
    
    example in class BeanTraverseBuilder
    
    Parameters:
    
    pojoClass - The POJO class.
    
    o - An instance of the POJO class used for examples.
    
    Returns:
    
    This object (for method chaining).
  - exampleJson
```
public <T> JsonSchemaGeneratorBuilder exampleJson(Class<T> pojoClass,
                                                  String json)
```
    Description copied from class: BeanContextBuilder
    BeanContext configuration property: POJO example.
    Specifies an example in JSON of the specified class.
    Examples are used in cases such as POJO examples in Swagger documents.
    Setting applies to specified class and all subclasses.
    Example:
    
    // Create a serializer that excludes the 'foo' and 'bar' properties on the MyBean class. WriterSerializer s = JsonSerializer .create() .example(MyBean.class, "{foo:'bar'}") .build();
    
    POJO examples can also be defined on classes via the following:
    - A static field annotated with @Example.
    - A static method annotated with @Example with zero arguments or one BeanSession argument.
    - A static method with name example with no arguments or one BeanSession argument.
    - BeanContext.BEAN_examples
    Overrides:
    
    exampleJson in class BeanTraverseBuilder
    
    Type Parameters:
    
    T - The POJO class type.
    
    Parameters:
    
    pojoClass - The POJO class.
    
    json - The simple JSON representation of the example.
    
    Returns:
    
    This object (for method chaining).
  - fluentSetters
```
public JsonSchemaGeneratorBuilder fluentSetters()
```
    Description copied from class: BeanContextBuilder
    BeanContext configuration property: Find fluent setters.
    When enabled, fluent setters are detected on beans during parsing.
    Fluent setters must have the following attributes:
    - Public.
    - Not static.
    - Take in one parameter.
    - Return the bean itself.
    Example:
    
    // A bean with a fluent setter. public class MyBean { public MyBean foo(String value) {...} } // Create a parser that finds fluent setters. ReaderParser p = JsonParser .create() .fluentSetters() .build(); // Same, but use property. ReaderParser p = JsonParser .create() .set(BEAN_fluentSetters, true) .build(); // Parse into bean using fluent setter. MyBean b = p.parse("{foo:'bar'}");
    - The @Beanp annotation can also be used on methods to individually identify them as fluent setters.
    - The @Bean.fluentSetters() annotation can also be used on classes to specify to look for fluent setters.
    - BeanContext.BEAN_fluentSetters
    Overrides:
    
    fluentSetters in class BeanTraverseBuilder
    
    Returns:
    
    This object (for method chaining).
  - fluentSetters
```
public JsonSchemaGeneratorBuilder fluentSetters(Class<?> on)
```
    Description copied from class: BeanContextBuilder
    BeanContext configuration property: Find fluent setters.
    Identical to BeanContextBuilder.fluentSetters() but enables it on a specific class only.
    Example:
    
    // A bean with a fluent setter. public class MyBean { public MyBean foo(String value) {...} } // Create a parser that finds fluent setters. ReaderParser p = JsonParser .create() .fluentSetters(MyBean.class) .build(); // Parse into bean using fluent setter. MyBean b = p.parse("{foo:'bar'}");
    - This method is functionally equivalent to using the Bean.fluentSetters() annotation.
    - Bean.fluentSetters()
    - BeanContext.BEAN_fluentSetters
    Overrides:
    
    fluentSetters in class BeanTraverseBuilder
    
    Parameters:
    
    on - The class that this applies to.
    
    Returns:
    
    This object (for method chaining).
  - ignoreInvocationExceptionsOnGetters
```
public JsonSchemaGeneratorBuilder ignoreInvocationExceptionsOnGetters()
```
    Description copied from class: BeanContextBuilder
    BeanContext configuration property: Ignore invocation errors on getters.
    When enabled, errors thrown when calling bean getter methods will silently be ignored. Otherwise, a BeanRuntimeException is thrown.
    Example:
    
    // A bean with a property that throws an exception. public class MyBean { public String getFoo() { throw new RuntimeException("foo"); } } // Create a serializer that ignores bean getter exceptions. WriterSerializer s = JsonSerializer .create() .ingoreInvocationExceptionsOnGetters() .build(); // Same, but use property. WriterSerializer s = JsonSerializer .create() .set(BEAN_ignoreInvocationExceptionsOnGetters, true) .build(); // Exception is ignored. String json = s.serialize(new MyBean());
    - BeanContext.BEAN_ignoreInvocationExceptionsOnGetters
    Overrides:
    
    ignoreInvocationExceptionsOnGetters in class BeanTraverseBuilder
    
    Returns:
    
    This object (for method chaining).
  - ignoreInvocationExceptionsOnSetters
```
public JsonSchemaGeneratorBuilder ignoreInvocationExceptionsOnSetters()
```
    Description copied from class: BeanContextBuilder
    BeanContext configuration property: Ignore invocation errors on setters.
    When enabled, errors thrown when calling bean setter methods will silently be ignored. Otherwise, a BeanRuntimeException is thrown.
    Example:
    
    // A bean with a property that throws an exception. public class MyBean { public void setFoo(String foo) { throw new RuntimeException("foo"); } } // Create a parser that ignores bean setter exceptions. ReaderParser p = JsonParser .create() .ignoreInvocationExceptionsOnSetters() .build(); // Same, but use property. ReaderParser p = JsonParser .create() .set(BEAN_ignoreInvocationExceptionsOnSetters, true) .build(); // Exception is ignored. MyBean b = p.parse("{foo:'bar'}", MyBean.class);
    - BeanContext.BEAN_ignoreInvocationExceptionsOnSetters
    Overrides:
    
    ignoreInvocationExceptionsOnSetters in class BeanTraverseBuilder
    
    Returns:
    
    This object (for method chaining).
  - ignoreUnknownBeanProperties
```
public JsonSchemaGeneratorBuilder ignoreUnknownBeanProperties()
```
    Description copied from class: BeanContextBuilder
    BeanContext configuration property: Ignore unknown properties.
    When enabled, trying to set a value on a non-existent bean property will silently be ignored. Otherwise, a BeanRuntimeException is thrown.
    Example:
    
    // A bean with a single property. public class MyBean { public String foo; } // Create a parser that ignores missing bean properties. ReaderParser p = JsonParser .create() .ignoreUnknownBeanProperties() .build(); // Same, but use property. ReaderParser p = JsonParser .create() .set(BEAN_ignoreUnknownBeanProperties, true) .build(); // Doesn't throw an exception on unknown 'bar' property. MyBean b = p.parse("{foo:'foo',bar:'bar'}", MyBean.class);
    - BeanContext.BEAN_ignoreUnknownBeanProperties
    Overrides:
    
    ignoreUnknownBeanProperties in class BeanTraverseBuilder
    
    Returns:
    
    This object (for method chaining).
  - implClass
```
public JsonSchemaGeneratorBuilder implClass(Class<?> interfaceClass,
                                            Class<?> implClass)
```
    Description copied from class: BeanContextBuilder
    BeanContext configuration property: Implementation classes.
    For interfaces and abstract classes this method can be used to specify an implementation class for the interface/abstract class so that instances of the implementation class are used when instantiated (e.g. during a parse).
    Example:
    
    // A bean interface. public interface MyBean { ... } // A bean implementation. public class MyBeanImpl implements MyBean { ... } // Create a parser that instantiates MyBeanImpls when parsing MyBeans. ReaderParser p = JsonParser .create() .implClass(MyBean.class, MyBeanImpl.class) .build(); // Same, but use property. ReaderParser p = JsonParser .create() .addTo(BEAN_implClasses, MyBean.class.getName(), MyBeanImpl.class) .build(); // Instantiates a MyBeanImpl, MyBean b = p.parse("...", MyBean.class);
    - BeanContext.BEAN_implClasses
    Overrides:
    
    implClass in class BeanTraverseBuilder
    
    Parameters:
    
    interfaceClass - The interface class.
    
    implClass - The implementation class.
    
    Returns:
    
    This object (for method chaining).
  - implClasses
```
public JsonSchemaGeneratorBuilder implClasses(Map<Class<?>,Class<?>> values)
```
    Description copied from class: BeanContextBuilder
    BeanContext configuration property: Implementation classes.
    For interfaces and abstract classes this method can be used to specify an implementation class for the interface/abstract class so that instances of the implementation class are used when instantiated (e.g. during a parse).
    Example:
    
    // A bean with a single property. public interface MyBean { ... } // A bean with a single property. public class MyBeanImpl implements MyBean { ... } // Create a parser that instantiates MyBeanImpls when parsing MyBeans. ReaderParser p = JsonParser .create() .implClasses(AMap.of(MyBean.class, MyBeanImpl.class)) .build(); // Same, but use property. ReaderParser p = JsonParser .create() .addTo(BEAN_implClasses, AMap.of(MyBean.class.getName(), MyBeanImpl.class)) .build(); // Instantiates a MyBeanImpl, MyBean b = p.parse("...", MyBean.class);
    - BeanContext.BEAN_implClasses
    Overrides:
    
    implClasses in class BeanTraverseBuilder
    
    Parameters:
    
    values - The new value for this property.
    
    Returns:
    
    This object (for method chaining).
  - interfaceClass
```
public JsonSchemaGeneratorBuilder interfaceClass(Class<?> on,
                                                 Class<?> value)
```
    Description copied from class: BeanContextBuilder
    Identifies a class to be used as the interface class for the specified class and all subclasses.
    When specified, only the list of properties defined on the interface class will be used during serialization. Additional properties on subclasses will be ignored.
    // Parent class or interface public abstract class A { public String foo = "foo"; } // Sub class public class A1 extends A { public String bar = "bar"; } // Create a serializer and define our interface class mapping. WriterSerializer s = JsonSerializer .create() .interfaceClass(A1.class, A.class) .build(); // Produces "{"foo":"foo"}" String json = s.serialize(new A1());
    
    This annotation can be used on the parent class so that it filters to all child classes, or can be set individually on the child classes.
    - The @Bean(interfaceClass) annotation is the equivalent annotation-based solution.
    Overrides:
    
    interfaceClass in class BeanTraverseBuilder
    
    Parameters:
    
    on - The class that the interface class applies to.
    
    value - The new value for this property.
    
    Returns:
    
    This object (for method chaining).
  - interfaces
```
public JsonSchemaGeneratorBuilder interfaces(Class<?>... value)
```
    Description copied from class: BeanContextBuilder
    Identifies a set of interfaces.
    When specified, only the list of properties defined on the interface class will be used during serialization of implementation classes. Additional properties on subclasses will be ignored.
    // Parent class or interface public abstract class A { public String foo = "foo"; } // Sub class public class A1 extends A { public String bar = "bar"; } // Create a serializer and define our interface class mapping. WriterSerializer s = JsonSerializer .create() .interfaces(A.class) .build(); // Produces "{"foo":"foo"}" String json = s.serialize(new A1());
    
    This annotation can be used on the parent class so that it filters to all child classes, or can be set individually on the child classes.
    - The @Bean(interfaceClass) annotation is the equivalent annotation-based solution.
    Overrides:
    
    interfaces in class BeanTraverseBuilder
    
    Parameters:
    
    value - The new value for this property.
    
    Returns:
    
    This object (for method chaining).
  - notBeanClasses
```
public JsonSchemaGeneratorBuilder notBeanClasses(Object... values)
```
    Description copied from class: BeanContextBuilder
    BeanContext configuration property: Bean class exclusions.
    List of classes that should not be treated as beans even if they appear to be bean-like. Not-bean classes are converted to Strings during serialization.
    Values can consist of any of the following types:
    - Classes.
    - Arrays and collections of classes.
    Example:
    
    // A bean with a single property. public class MyBean { public String foo = "bar"; public String toString() { return "baz"; } } // Create a serializer that doesn't treat MyBean as a bean class. WriterSerializer s = JsonSerializer .create() .notBeanClasses(MyBean.class) .build(); // Same, but use property. WriterSerializer s = JsonSerializer .create() .addTo(BEAN_notBeanClasses, MyBean.class) .build(); // Produces "baz" instead of {"foo":"bar"} String json = s.serialize(new MyBean());
    - The @BeanIgnore annotation can also be used on classes to prevent them from being recognized as beans.
    - BeanContext.BEAN_notBeanClasses
    Overrides:
    
    notBeanClasses in class BeanTraverseBuilder
    
    Parameters:
    values - The values to add to this property.
    Values can consist of any of the following types:
    
    Classes.
    Arrays and collections of classes.
    Returns:
    
    This object (for method chaining).
  - notBeanPackages
```
public JsonSchemaGeneratorBuilder notBeanPackages(Object... values)
```
    Description copied from class: BeanContextBuilder
    BeanContext configuration property: Bean package exclusions.
    Used as a convenient way of defining the BeanContextBuilder.notBeanClasses(Object...) property for entire packages. Any classes within these packages will be serialized to strings using Object.toString().
    Note that you can specify suffix patterns to include all subpackages.
    Values can consist of any of the following types:
    - Strings.
    - Arrays and collections of strings.
    Example:
    
    // Create a serializer that ignores beans in the specified packages. WriterSerializer s = JsonSerializer .create() .notBeanPackages("org.apache.foo", "org.apache.bar.*") .build(); // Same, but use property. WriterSerializer s = JsonSerializer .create() .addTo(BEAN_notBeanPackages, "org.apache.foo") .addTo(BEAN_notBeanPackages, "org.apache.bar.*") .build();
    - BeanContext.BEAN_notBeanPackages
    Overrides:
    
    notBeanPackages in class BeanTraverseBuilder
    
    Parameters:
    values - The values to add to this property.
    Values can consist of any of the following types:
    
    Package objects.
    Strings.
    Arrays and collections of anything in this list.
    Returns:
    
    This object (for method chaining).
  - propertyNamer
```
public JsonSchemaGeneratorBuilder propertyNamer(Class<? extends PropertyNamer> value)
```
    Description copied from class: BeanContextBuilder
    BeanContext configuration property: Bean property namer
    The class to use for calculating bean property names.
    Predefined classes:
    - PropertyNamerDefault - Default.
    - PropertyNamerDLC - Dashed-lower-case names.
    - PropertyNamerULC - Dashed-upper-case names.
    Example:
    
    // A bean with a single property. public class MyBean { public String fooBarBaz = "fooBarBaz"; } // Create a serializer that uses Dashed-Lower-Case property names. // (e.g. "foo-bar-baz" instead of "fooBarBaz") WriterSerializer s = JsonSerializer .create() .propertyNamer(PropertyNamerDLC.class) .build(); // Same, but use property. WriterSerializer s = JsonSerializer .create() .set(BEAN_propertyNamer, PropertyNamerDLC.class) .build(); // Produces: {"foo-bar-baz":"fooBarBaz"} String json = s.serialize(new MyBean());
    - BeanContext.BEAN_propertyNamer
    Overrides:
    
    propertyNamer in class BeanTraverseBuilder
    
    Parameters:
    
    value - The new value for this setting.
    The default is PropertyNamerDefault.
    
    Returns:
    
    This object (for method chaining).
  - propertyNamer
```
public JsonSchemaGeneratorBuilder propertyNamer(Class<?> on,
                                                Class<? extends PropertyNamer> value)
```
    Description copied from class: BeanContextBuilder
    Bean property namer
    Same as BeanContextBuilder.propertyNamer(Class) but allows you to specify a namer for a specific class.
    Example:
    
    // A bean with a single property. public class MyBean { public String fooBarBaz = "fooBarBaz"; } // Create a serializer that uses Dashed-Lower-Case property names for the MyBean class only. // (e.g. "foo-bar-baz" instead of "fooBarBaz") WriterSerializer s = JsonSerializer .create() .propertyNamer(MyBean.class, PropertyNamerDLC.class) .build(); // Produces: {"foo-bar-baz":"fooBarBaz"} String json = s.serialize(new MyBean());
    - Bean(propertyNamer)
    - BeanContext.BEAN_propertyNamer
    Overrides:
    
    propertyNamer in class BeanTraverseBuilder
    
    Parameters:
    
    on - The class that the namer applies to.
    
    value - The new value for this setting.
    The default is PropertyNamerDefault.
    
    Returns:
    
    This object (for method chaining).
  - sortProperties
```
public JsonSchemaGeneratorBuilder sortProperties()
```
    Description copied from class: BeanContextBuilder
    BeanContext configuration property: Sort bean properties.
    When enabled, all bean properties will be serialized and access in alphabetical order. Otherwise, the natural order of the bean properties is used which is dependent on the JVM vendor. On IBM JVMs, the bean properties are ordered based on their ordering in the Java file. On Oracle JVMs, the bean properties are not ordered (which follows the official JVM specs).
    This property is disabled by default so that IBM JVM users don't have to use @Bean annotations to force bean properties to be in a particular order and can just alter the order of the fields/methods in the Java file.
    Example:
    
    // A bean with 3 properties. public class MyBean { public String c = "1"; public String b = "2"; public String a = "3"; } // Create a serializer that sorts bean properties. WriterSerializer s = JsonSerializer .create() .sortProperties() .build(); // Same, but use property. WriterSerializer s = JsonSerializer .create() .set(BEAN_sortProperties, true) .build(); // Produces: {"a":"3","b":"2","c":"1"} String json = s.serialize(new MyBean());
    - The @Bean.sort() annotation can also be used to sort properties on just a single class.
    - BeanContext.BEAN_sortProperties
    Overrides:
    
    sortProperties in class BeanTraverseBuilder
    
    Returns:
    
    This object (for method chaining).
  - sortProperties
```
public JsonSchemaGeneratorBuilder sortProperties(Class<?>... on)
```
    Description copied from class: BeanContextBuilder
    Sort bean properties.
    Same as BeanContextBuilder.sortProperties() but allows you to specify individual bean classes instead of globally.
    Example:
    
    // A bean with 3 properties. public class MyBean { public String c = "1"; public String b = "2"; public String a = "3"; } // Create a serializer that sorts properties on MyBean. WriterSerializer s = JsonSerializer .create() .sortProperties(MyBean.class) .build(); // Produces: {"a":"3","b":"2","c":"1"} String json = s.serialize(new MyBean());
    - Bean(sort)
    - BeanContext.BEAN_sortProperties
    Overrides:
    
    sortProperties in class BeanTraverseBuilder
    
    Parameters:
    
    on - The bean classes to sort properties on.
    
    Returns:
    
    This object (for method chaining).
  - stopClass
```
public JsonSchemaGeneratorBuilder stopClass(Class<?> on,
                                            Class<?> value)
```
    Description copied from class: BeanContextBuilder
    
    Identifies a stop class for the annotated class.
    Identical in purpose to the stop class specified by Introspector.getBeanInfo(Class, Class). Any properties in the stop class or in its base classes will be ignored during analysis.
    For example, in the following class hierarchy, instances of C3 will include property p3, but not p1 or p2.
    Example:
    
    public class C1 { public int getP1(); } public class C2 extends C1 { public int getP2(); } public class C3 extends C2 { public int getP3(); } // Create a serializer specifies a stop class for C3. WriterSerializer s = JsonSerializer .create() .stopClass(C3.class, C2.class) .build(); // Produces: {"p3":"..."} String json = s.serialize(new C3());
    
    Overrides:
    
    stopClass in class BeanTraverseBuilder
    
    Parameters:
    
    on - The class on which the stop class is being applied.
    
    value - The new value for this property.
    
    Returns:
    
    This object (for method chaining).
  - swaps
```
public JsonSchemaGeneratorBuilder swaps(Object... values)
```
    Description copied from class: BeanContextBuilder
    BeanContext configuration property: Java object swaps.
    Swaps are used to "swap out" non-serializable classes with serializable equivalents during serialization, and "swap in" the non-serializable class during parsing.
    An example of a swap would be a Calendar object that gets swapped out for an ISO8601 string.
    Multiple swaps can be associated with a single class. When multiple swaps are applicable to the same class, the media type pattern defined by PojoSwap.forMediaTypes() or @Swap(mediaTypes) are used to come up with the best match.
    Values can consist of any of the following types:
    - Any subclass of PojoSwap.
    - Any instance of PojoSwap.
    - Any surrogate class. A shortcut for defining a SurrogateSwap.
    - Any array or collection of the objects above.
    Example:
    
    // Sample swap for converting Dates to ISO8601 strings. public class MyDateSwap extends StringSwap<Date> { // ISO8601 formatter. private DateFormat format = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ssZ"); @Override public String swap(BeanSession session, Date o) { return format.format(o); } @Override public Date unswap(BeanSession session, String o, ClassMeta hint) throws Exception { return format.parse(o); } } // Sample bean with a Date field. public class MyBean { public Date date = new Date(112, 2, 3, 4, 5, 6); } // Create a serializer that uses our date swap. WriterSerializer s = JsonSerializer .create() .swaps(MyDateSwap.class) .build(); // Same, but use property. WriterSerializer s = JsonSerializer .create() .addTo(BEAN_swaps, MyDateSwap.class) .build(); // Produces: {"date":"2012-03-03T04:05:06-0500"} String json = s.serialize(new MyBean()); // Create a serializer that uses our date swap. ReaderParser p = JsonParser .create() .swaps(MyDateSwap.class) .build(); // Use our parser to parse a bean. MyBean bean = p.parse(json, MyBean.class);
    - The @Swap annotation can also be used on classes to identify swaps for the class.
    - The @Swap annotation can also be used on bean methods and fields to identify swaps for values of those bean properties.
    - BeanContext.BEAN_swaps
    Overrides:
    
    swaps in class BeanTraverseBuilder
    
    Parameters:
    values - The values to add to this property.
    Values can consist of any of the following types:
    
    Any subclass of PojoSwap.
    Any surrogate class. A shortcut for defining a SurrogateSwap.
    Any array or collection of the objects above.
    Returns:
    
    This object (for method chaining).
  - typeName
```
public JsonSchemaGeneratorBuilder typeName(Class<?> on,
                                           String value)
```
    Description copied from class: BeanContextBuilder
    An identifying name for this class.
    The name is used to identify the class type during parsing when it cannot be inferred through reflection. For example, if a bean property is of type Object, then the serializer will add the name to the output so that the class can be determined during parsing.
    It is also used to specify element names in XML.
    Example:
    
    // Use _type='mybean' to identify this bean. public class MyBean {...} // Create a serializer and specify the type name.. WriterSerializer s = JsonSerializer .create() .typeName(MyBean.class, "mybean") .build(); // Produces: {"_type":"mybean",...} String json = s.serialize(new MyBean());
    - Equivalent to the Bean(typeName) annotation.
    - Bean(typeName)
    - BeanContext.BEAN_beanDictionary
    Overrides:
    
    typeName in class BeanTraverseBuilder
    
    Parameters:
    
    on - The class the type name is being defined on.
    
    value - The new value for this property.
    
    Returns:
    
    This object (for method chaining).
  - typePropertyName
```
public JsonSchemaGeneratorBuilder typePropertyName(String value)
```
    Description copied from class: BeanContextBuilder
    BeanContext configuration property: Bean type property name.
    This specifies the name of the bean property used to store the dictionary name of a bean type so that the parser knows the data type to reconstruct.
    Example:
    
    // POJOs with @Bean(name) annotations. @Bean(typeName="foo") public class Foo {...} @Bean(typeName="bar") public class Bar {...} // Create a serializer that uses 't' instead of '_type' for dictionary names. WriterSerializer s = JsonSerializer .create() .typePropertyName("t") .dictionary(Foo.class, Bar.class) .build(); // Same, but use property. WriterSerializer s = JsonSerializer .create() .set(BEAN_typePropertyName, "t") .addTo(BEAN_beanDictionary, Foo.class) .addTo(BEAN_beanDictionary, Bar.class) .build(); // A bean with a field with an indeterminate type. public class MyBean { public Object mySimpleField; } // Parse bean. MyBean b = p.parse("{mySimpleField:{t:'foo',...}}", MyBean.class);
    - BeanContext.BEAN_typePropertyName
    Overrides:
    
    typePropertyName in class BeanTraverseBuilder
    
    Parameters:
    
    value - The new value for this property.
    The default is "_type".
    
    Returns:
    
    This object (for method chaining).
  - typePropertyName
```
public JsonSchemaGeneratorBuilder typePropertyName(Class<?> on,
                                                   String value)
```
    Description copied from class: BeanContextBuilder
    BeanContext configuration property: Bean type property name.
    Same as BeanContextBuilder.typePropertyName(String) except targets a specific bean class instead of globally.
    Example:
    
    // POJOs with @Bean(name) annotations. @Bean(typeName="foo") public class Foo {...} @Bean(typeName="bar") public class Bar {...} // A bean with a field with an indeterminate type. public class MyBean { public Object mySimpleField; } // Create a serializer that uses 't' instead of '_type' for dictionary names. WriterSerializer s = JsonSerializer .create() .typePropertyName(MyBean.class, "t") .dictionary(Foo.class, Bar.class) .build(); // Parse bean. MyBean b = p.parse("{mySimpleField:{t:'foo',...}}", MyBean.class);
    - Bean(typePropertyName)
    - BeanContext.BEAN_typePropertyName
    Overrides:
    
    typePropertyName in class BeanTraverseBuilder
    
    Parameters:
    
    on - The class the type property name applies to.
    
    value - The new value for this property.
    The default is "_type".
    
    Returns:
    
    This object (for method chaining).
  - useEnumNames
```
public JsonSchemaGeneratorBuilder useEnumNames()
```
    Description copied from class: BeanContextBuilder
    BeanContext configuration property: Use enum names.
    When enabled, enums are always serialized by name, not using Object.toString().
    Example:
    
    // Create a serializer with debug enabled. WriterSerializer s = JsonSerializer .create() .useEnumNames() .build(); // Same, but use property. WriterSerializer s = JsonSerializer .create() .set(BEAN_useEnumNames, true) .build(); // Enum with overridden toString(). // Will be serialized as ONE/TWO/THREE even though there's a toString() method. public enum Option { ONE(1), TWO(2), THREE(3); private int i; Option(int i) { this.i = i; } @Override public String toString() { return String.valueOf(i); } }
    - BeanContext.BEAN_useEnumNames
    Overrides:
    
    useEnumNames in class BeanTraverseBuilder
    
    Returns:
    
    This object (for method chaining).
  - useJavaBeanIntrospector
```
public JsonSchemaGeneratorBuilder useJavaBeanIntrospector()
```
    Description copied from class: BeanContextBuilder
    BeanContext configuration property: Use Java Introspector.
    Using the built-in Java bean introspector will not pick up fields or non-standard getters/setters.
    Most @Bean annotations will be ignored.
    Example:
    
    // Create a serializer that only uses the built-in java bean introspector for finding properties. WriterSerializer s = JsonSerializer .create() .useJavaBeanIntrospector() .build(); // Same, but use property. WriterSerializer s = JsonSerializer .create() .set(BEAN_useJavaBeanIntrospector, true) .build();
    - BeanContext.BEAN_useJavaBeanIntrospector
    Overrides:
    
    useJavaBeanIntrospector in class BeanTraverseBuilder
    
    Returns:
    
    This object (for method chaining).
  - detectRecursions
```
public JsonSchemaGeneratorBuilder detectRecursions()
```
    Description copied from class: BeanTraverseBuilder
    BeanTraverse configuration property: Automatically detect POJO recursions.
    When enabled, specifies that recursions should be checked for during traversal.
    Recursions can occur when traversing models that aren't true trees but rather contain loops.
    In general, unchecked recursions cause stack-overflow-errors.
    These show up as BeanRecursionException with the message "Depth too deep. Stack overflow occurred.".
    - Checking for recursion can cause a small performance penalty.
    Example:
    
    // Create a serializer that automatically checks for recursions. WriterSerializer s = JsonSerializer .create() .detectRecursions() .build(); // Create a POJO model with a recursive loop. public class A { public Object f; } A a = new A(); a.f = a; // Throws a SerializeException and not a StackOverflowError String json = s.serialize(a);
    - BeanTraverseContext.BEANTRAVERSE_detectRecursions
    Overrides:
    
    detectRecursions in class BeanTraverseBuilder
    
    Returns:
    
    This object (for method chaining).
  - ignoreRecursions
```
public JsonSchemaGeneratorBuilder ignoreRecursions()
```
    Description copied from class: BeanTraverseBuilder
    BeanTraverse configuration property: Ignore recursion errors.
    When enabled, when we encounter the same object when traversing a tree, we set the value to null.
    For example, if a model contains the links A->B->C->A, then the JSON generated will look like the following when BEANTRAVERSE_ignoreRecursions is true...
    {A:{B:{C:null}}}
    - Checking for recursion can cause a small performance penalty.
    Example:
    
    // Create a serializer ignores recursions. WriterSerializer s = JsonSerializer .create() .ignoreRecursions() .build(); // Create a POJO model with a recursive loop. public class A { public Object f; } A a = new A(); a.f = a; // Produces "{f:null}" String json = s.serialize(a);
    - BeanTraverseContext.BEANTRAVERSE_ignoreRecursions
    Overrides:
    
    ignoreRecursions in class BeanTraverseBuilder
    
    Returns:
    
    This object (for method chaining).
  - initialDepth
```
public JsonSchemaGeneratorBuilder initialDepth(int value)
```
    Description copied from class: BeanTraverseBuilder
    BeanTraverse configuration property: Initial depth.
    The initial indentation level at the root.
    Useful when constructing document fragments that need to be indented at a certain level when whitespace is enabled.
    Example:
    
    // Create a serializer with whitespace enabled and an initial depth of 2. WriterSerializer s = JsonSerializer .create() .ws() .initialDepth(2) .build(); // Produces "\t\t{\n\t\t\t'foo':'bar'\n\t\t}\n" String json = s.serialize(new MyBean());
    - BeanTraverseContext.BEANTRAVERSE_initialDepth
    Overrides:
    
    initialDepth in class BeanTraverseBuilder
    
    Parameters:
    
    value - The new value for this property.
    The default is 0.
    
    Returns:
    
    This object (for method chaining).
  - maxDepth
```
public JsonSchemaGeneratorBuilder maxDepth(int value)
```
    Description copied from class: BeanTraverseBuilder
    BeanTraverse configuration property: Max traversal depth.
    When enabled, abort traversal if specified depth is reached in the POJO tree.
    If this depth is exceeded, an exception is thrown.
    This prevents stack overflows from occurring when trying to traverse models with recursive references.
    Example:
    
    // Create a serializer that throws an exception if the depth reaches greater than 20. WriterSerializer s = JsonSerializer .create() .maxDepth(20) .build();
    - BeanTraverseContext.BEANTRAVERSE_maxDepth
    Overrides:
    
    maxDepth in class BeanTraverseBuilder
    
    Parameters:
    
    value - The new value for this property.
    The default is 100.
    
    Returns:
    
    This object (for method chaining).

Class JsonSchemaGeneratorBuilder

Constructor Summary

Method Summary

Methods inherited from class org.apache.juneau.BeanTraverseBuilder

Methods inherited from class org.apache.juneau.BeanContextBuilder

Methods inherited from class org.apache.juneau.ContextBuilder

Methods inherited from class java.lang.Object

Constructor Detail

JsonSchemaGeneratorBuilder

JsonSchemaGeneratorBuilder

Method Detail

build

addDescriptionsTo

addExamplesTo

allowNestedDescriptions

allowNestedDescriptions

allowNestedExamples

allowNestedExamples

beanDefMapper

beanDefMapper

defaultSchema

ignoreTypes

Description:

Example:

useBeanDefs

useBeanDefs

add

Example:

addTo

Example:

appendTo

Example:

apply

Example:

applyAnnotations

Example:

applyAnnotations

Example:

applyAnnotations

Example:

debug

Example:

locale

Example:

mediaType

Example:

prependTo

Example:

putAllTo

Example:

putTo

Example:

removeFrom

Example:

set

Example:

set

Example:

Example:

timeZone

Example:

annotations

beanClassVisibility

Example:

beanConstructorVisibility

Example:

beanFieldVisibility

Example:

beanInterceptor

Example:

beanMapPutReturnsOldValue

Example:

beanMethodVisibility

Example:

beansDontRequireSomeProperties

Example:

beansRequireDefaultConstructor

Example:

beansRequireSerializable

Example: