shinkansen-transmission 2.3.6 → 2.4.0

package/index.d.mts

@@ -5,38 +5,38 @@ declare global {
     export type ArrayLiteralType = never[]
     export type ArrayType = unknown[]
 
-    export type ItemsType = string[] | number[] | object[] | boolean[] | null[]
-
-    export type SelectedItemsType = Array<string | number | boolean | null>
+    export type MemberArrayType = string[] | number[] | object[] | boolean[] | null[]
+    export type MemberType = string | number | object | boolean | null
+    export type SelectedMemberArrayType = MemberType[]
 
     export interface EnumType {
       id: string
       name?: string
-      items?: ItemsType
-      selectedItems?: SelectedItemsType
+      items?: MemberArrayType
+      selectedItems?: SelectedMemberArrayType
     }
 
     export interface AnyOfType {
       id: string
       name?: string
-      items?: ItemsType
-      selectedItems?: SelectedItemsType
+      items?: MemberArrayType
+      selectedItems?: SelectedMemberArrayType
     }
 
     export interface OneOfType {
       id: string
       name?: string
-      items?: ItemsType
-      selectedItems?: SelectedItemsType
+      items?: MemberArrayType
+      selectedItems?: SelectedMemberArrayType
     }
 
     export interface FieldType {
       id: string
       name?: string
-      items?: ItemsType
-      selectedItems?: SelectedItemsType
-      value?: string | number | boolean | null | object | ItemsType
-      defaultValue?: string | number | boolean | null | object | ItemsType
+      items?: MemberArrayType
+      selectedItems?: SelectedMemberArrayType
+      value?: MemberType | MemberArrayType
+      defaultValue?: MemberType | MemberArrayType
     }
 
     export interface SchemaType {
@@ -48,12 +48,12 @@ declare global {
       required?: string[]
       readOnly?: boolean
       writeOnly?: boolean
-      const?: string | number | object | boolean | null
-      default?: string | number | object | boolean | null
-      enum?: ItemsType
-      anyOf?: ItemsType
-      oneOf?: ItemsType
-      allOf?: ItemsType
+      const?: MemberType
+      default?: MemberType
+      enum?: MemberArrayType
+      anyOf?: MemberArrayType
+      oneOf?: MemberArrayType
+      allOf?: MemberArrayType
       minimum?: number
       maximum?: number
       minLength?: number
@@ -111,8 +111,8 @@ declare global {
       defaultValue?: string
       item?: number
       name?: string
-      selectedItems?: SelectedItemsType
-      items?: ItemsType
+      selectedItems?: SelectedMemberArrayType
+      items?: MemberArrayType
       isRequired?: boolean
       component?: string
     }
@@ -319,7 +319,7 @@ declare global {
     /**
      *  A JSON Schema document
      */
-    export type DocumentType = string | number | object | boolean | null | string[] | number[] | object[] | boolean[] | null[]
+    export type DocumentType = MemberType | MemberArrayType
 
     /**
      *  String keys with string or string array values

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "shinkansen-transmission",
-  "version": "2.3.6",
+  "version": "2.4.0",
   "description": "Shinkansen Transmission",
   "keywords": [
     "Shinkansen",

package/src/transmission/common/index.d.mts

@@ -1,7 +1,8 @@
 export type ObjectLiteralType = TransmissionTypes.ObjectLiteralType
 export type ObjectType = TransmissionTypes.ObjectType
 
-export type ItemsType = TransmissionTypes.ItemsType
+export type MemberArrayType = TransmissionTypes.MemberArrayType
+export type MemberType = TransmissionTypes.MemberType
 
 export type StringMetaType = TransmissionTypes.Transmission.StringMetaType
 export type NumberMetaType = TransmissionTypes.Transmission.NumberMetaType
@@ -34,8 +35,8 @@ export type NullSchemaType = TransmissionTypes.NullSchemaType
 export type ValuesType = TransmissionTypes.ValuesType
 export type ParamsType = TransmissionTypes.ParamsType
 
-export function isObject (v?: unknown): v is (Record<PropertyKey, string | number | object | boolean | null | string[] | number[] | object[] | boolean[] | null[]> | Record<PropertyKey, never>)
-export function isArray (v?: unknown): v is (string[] | number[] | object[] | boolean[] | null[])
+export function isObject (v?: unknown): v is (Record<PropertyKey, MemberType | MemberArrayType> | Record<PropertyKey, never>)
+export function isArray (v?: unknown): v is (MemberArrayType)
 export function isPrimitive (v?: unknown): v is string | number | boolean | null
 
 export function isSchema (v?: SchemaType | object): v is SchemaType
@@ -61,14 +62,14 @@ export function getMetaDefaultValue (schema?: SchemaType): { defaultValue: strin
 export function hasMetaValue (values?: ValuesType, uri?: string, schema?: SchemaType): boolean
 export function getMetaValue (values?: ValuesType, uri?: string, schema?: SchemaType): { value: string } | ObjectLiteralType
 
-export function transformToValue (schema?: string | number | object | boolean | null): string | number | object | boolean | null | undefined
+export function transformToValue (schema?: MemberType): MemberType | undefined
 
 export function getFindByKey (parentUri: string, uri: string): (key: string | number) => boolean
 export function getFindByIndex (parentUri: string, uri: string): (item: SchemaType, index: number) => boolean
-export function getFindByValue (value?: string | number | object | boolean | null): (item?: string | number | object | boolean | null | string[] | number[] | object[] | boolean[] | null[]) => boolean
-export function getFindByEqual (value?: string | number | object | boolean | null): (item?: string | number | object | boolean | null | string[] | number[] | object[] | boolean[] | null[]) => boolean
+export function getFindByValue (value?: MemberType): (item?: MemberType | MemberArrayType) => boolean
+export function getFindByEqual (value?: MemberType): (item?: MemberType | MemberArrayType) => boolean
 
-export function toString (value?: string | number | object | boolean | null): string
+export function toString (value?: MemberType): string
 
 export function getArray (schema?: { items?: SchemaType | SchemaType[] }, parentUri?: string, uri?: string): SchemaType | undefined
 export function getObject (schema?: { properties?: Record<string, SchemaType> }, parentUri?: string, uri?: string): SchemaType | undefined
@@ -94,24 +95,15 @@ declare function getSchema (
 
 export { getSchema }
 
-export function transformValueIndexFor (array: string[] | number[] | object[] | boolean[] | null[], value?: string | number | object | boolean | null): string
-export function transformEqualIndexFor (array: string[] | number[] | object[] | boolean[] | null[], value?: string | number | object | boolean | null): string
+export function transformIndexToValueByFindValue (array: MemberArrayType, value?: MemberType): string
+export function transformIndexToValueByFindEqual (array: MemberArrayType, value?: MemberType): string
 
-export function getIndexByValue (array: string[] | number[] | object[] | boolean[] | null[], value?: string | number | object | boolean | null): number
-export function getIndexByEqual (array: string[] | number[] | object[] | boolean[] | null[], value?: string | number | object | boolean | null): number
+export function findIndexByValue (array: MemberArrayType, value?: MemberType): number
+export function findIndexByEqual (array: MemberArrayType, value?: MemberType): number
 
 export function hasValue (values?: ValuesType, uri?: string, schema?: SchemaType): boolean
 export function getValue (values?: ValuesType, uri?: string, schema?: SchemaType): string
 
-export function getValueForEnum (v: string | number, schema?: { enum?: ItemsType }): string
-export function getIndexForEnum (values?: ValuesType, parentUri?: string, uri?: string, schema?: SchemaType): number
-
-export function getValueForAnyOf (v: string | number, schema?: { anyOf?: ItemsType }): string
-export function getIndexForAnyOf (values?: ValuesType, parentUri?: string, uri?: string, schema?: SchemaType): number
-
-export function getValueForOneOf (v: string | number, schema?: { oneOf?: ItemsType }): string
-export function getIndexForOneOf (values: ValuesType, parentUri?: string, uri?: string, schema?: SchemaType): number
-
 export function getElementsProps (params?: ParamsType, uri?: string): StringElementsType | NumberElementsType | ArrayElementsType | ObjectElementsType | BooleanElementsType | NullElementsType | Record<string, never>
 
 export function getElementsFieldPropsForEnum (params?: ParamsType, uri?: string): EnumType | ObjectLiteralType
@@ -121,45 +113,45 @@ export function getElementsFieldPropsForAllOf (params?: ParamsType, uri?: string
 export function getElementsFieldProps (params?: ParamsType, uri?: string): FieldType | ObjectLiteralType
 export function getElementsFieldValue (values?: ValuesType, uri?: string, schema?: SchemaType): { value: string } | ObjectLiteralType
 
-export function hasEnum (schema?: { enum?: ItemsType }): schema is { enum: ItemsType }
+export function hasEnum (schema?: { enum?: MemberArrayType }): schema is { enum: MemberArrayType }
 
-declare function getEnum (schema: { enum: ItemsType }): ItemsType
-declare function getEnum (schema?: { enum?: ItemsType }): ItemsType | undefined
+declare function getEnum (schema: { enum: MemberArrayType }): MemberArrayType
+declare function getEnum (schema?: { enum?: MemberArrayType }): MemberArrayType | undefined
 
 export { getEnum }
 
-export function hasConst (schema?: { const?: string | number | object | boolean | null }): schema is { const: string | number | object | boolean | null }
+export function hasConst (schema?: { const?: MemberType }): schema is { const: MemberType }
 
-declare function getConst (schema: { const: string | number | object | boolean | null }): string | number | object | boolean | null
-declare function getConst (schema?: { const?: string | number | object | boolean | null }): string | number | object | boolean | null | undefined
+declare function getConst (schema: { const: MemberType }): MemberType
+declare function getConst (schema?: { const?: MemberType }): MemberType | undefined
 
 export { getConst }
 
-export function hasDefault (schema?: { default?: string | number | object | boolean | null }): schema is { default: string | number | object | boolean | null }
+export function hasDefault (schema?: { default?: MemberType }): schema is { default: MemberType }
 
-declare function getDefault (schema: { default: string | number | object | boolean | null }): string | number | object | boolean | null
-declare function getDefault (schema?: { default?: string | number | object | boolean | null }): string | number | object | boolean | null | undefined
+declare function getDefault (schema: { default: MemberType }): MemberType
+declare function getDefault (schema?: { default?: MemberType }): MemberType | undefined
 
 export { getDefault }
 
-export function hasAnyOf (schema?: { anyOf?: ItemsType }): schema is { anyOf: ItemsType }
+export function hasAnyOf (schema?: { anyOf?: MemberArrayType }): schema is { anyOf: MemberArrayType }
 
-declare function getAnyOf (schema: { anyOf: ItemsType }): ItemsType
-declare function getAnyOf (schema?: { anyOf?: ItemsType }): ItemsType | undefined
+declare function getAnyOf (schema: { anyOf: MemberArrayType }): MemberArrayType
+declare function getAnyOf (schema?: { anyOf?: MemberArrayType }): MemberArrayType | undefined
 
 export { getAnyOf }
 
-export function hasOneOf (schema?: { oneOf?: ItemsType }): schema is { oneOf: ItemsType }
+export function hasOneOf (schema?: { oneOf?: MemberArrayType }): schema is { oneOf: MemberArrayType }
 
-declare function getOneOf (schema: { oneOf: ItemsType }): ItemsType
-declare function getOneOf (schema?: { oneOf?: ItemsType }): ItemsType | undefined
+declare function getOneOf (schema: { oneOf: MemberArrayType }): MemberArrayType
+declare function getOneOf (schema?: { oneOf?: MemberArrayType }): MemberArrayType | undefined
 
 export { getOneOf }
 
-export function hasAllOf (schema?: { allOf?: ItemsType }): schema is { allOf: ItemsType }
+export function hasAllOf (schema?: { allOf?: MemberArrayType }): schema is { allOf: MemberArrayType }
 
-declare function getAllOf (schema: { allOf: ItemsType }): ItemsType
-declare function getAllOf (schema?: { allOf?: ItemsType }): ItemsType | undefined
+declare function getAllOf (schema: { allOf: MemberArrayType }): MemberArrayType
+declare function getAllOf (schema?: { allOf?: MemberArrayType }): MemberArrayType | undefined
 
 export { getAllOf }
 

package/src/transmission/common/index.mjs

@@ -2,7 +2,8 @@
  *  @typedef {TransmissionTypes.ObjectLiteralType} ObjectLiteralType
  *  @typedef {TransmissionTypes.ObjectType} ObjectType
  *
- *  @typedef {TransmissionTypes.ItemsType} ItemsType
+ *  @typedef {TransmissionTypes.MemberArrayType} MemberArrayType
+ *  @typedef {TransmissionTypes.MemberType} MemberType
  *
  *  @typedef {TransmissionTypes.Transmission.StringMetaType} TransmissionStringMetaType
  *  @typedef {TransmissionTypes.Transmission.NumberMetaType} TransmissionNumberMetaType
@@ -46,13 +47,13 @@ log('`shinkansen` is awake')
 
 /**
  *  @param {unknown} [v]
- *  @returns {v is (Record<PropertyKey, string | number | object | boolean | null | string[] | number[] | object[] | boolean[] | null[]> | Record<PropertyKey, never>)}
+ *  @returns {v is (Record<PropertyKey, MemberType | MemberArrayType> | Record<PropertyKey, never>)}
  */
 export const isObject = (v) => (v || false) instanceof Object && !isArray(v)
 
 /**
  *  @param {unknown} [v]
- *  @returns {v is (string[] | number[] | object[] | boolean[] | null[])} //  | SchemaType)[]}
+ *  @returns {v is (MemberArrayType)} //  | SchemaType)[]}
  */
 export const isArray = (v) => Array.isArray(v)
 
@@ -304,8 +305,8 @@ export function getMetaValue (values = {}, uri = '#', schema = {}) {
 }
 
 /**
- *  @param {string | number | object | boolean | null} [item]
- *  @returns {string | number | object | boolean | null | undefined}
+ *  @param {MemberType} [item]
+ *  @returns {MemberType | undefined}
  */
 export function transformToValue (item) {
   if (item === undefined) return item
@@ -366,8 +367,8 @@ export function getFindByIndex (parentUri, uri) {
 }
 
 /**
- *  @param {string | number | object | boolean | null} [value]
- *  @returns {(item?: string | number | object | boolean | null | string[] | number[] | object[] | boolean[] | null[]) => boolean}
+ *  @param {MemberType} [value]
+ *  @returns {(item?: MemberType | MemberArrayType) => boolean}
  */
 export function getFindByValue (value) {
   /*
@@ -384,8 +385,8 @@ export function getFindByValue (value) {
 }
 
 /**
- *  @param {string | number | object | boolean | null} [value]
- *  @returns {(item?: string | number | object | boolean | null | string[] | number[] | object[] | boolean[] | null[]) => boolean}
+ *  @param {MemberType} [value]
+ *  @returns {(item?: MemberType | MemberArrayType) => boolean}
  */
 export function getFindByEqual (value) {
   /*
@@ -400,7 +401,7 @@ export function getFindByEqual (value) {
 }
 
 /**
- *  @param {string | number | object | boolean | null} [value]
+ *  @param {MemberType} [value]
  *  @returns {string}
  */
 export function toString (value) {
@@ -502,86 +503,72 @@ export function getSchema (schema = {}, parentUri = '', uri = '') {
 }
 
 /**
- *  @param {string[] | number[] | object[] | boolean[] | null[]} array
- *  @param {string | number | object | boolean | null} [value]
+ *  @param {MemberArrayType} array
+ *  @param {MemberType} [value]
  *  @returns {string}
  */
-export function transformValueIndexFor (array, value) {
+export function transformIndexToValueByFindValue (array, value) {
   /*
-   *  log('transformEqualIndexFor')
+   *  log('transformIndexToValueByFindValue')
    */
 
-  const find = getFindByValue(value)
-
-  if (array.some(find)) {
-    const index = array.findIndex(find)
-
-    /*
-     *  Transform a number to a string
-     */
-    return String(index)
-  }
+  const index = findIndexByValue(array, value)
 
   /*
-   *  Takes the place of `toString(document)` in `transform()`
+   *  Transform a number to a string
    */
-  return toString(value)
+  return String(index)
 }
 
 /**
- *  @param {string[] | number[] | object[] | boolean[] | null[]} array
- *  @param {string | number | object | boolean | null} [value]
+ *  @param {MemberArrayType} array
+ *  @param {MemberType} [value]
  *  @returns {number}
  */
-export function getIndexByValue (array, value) {
+export function findIndexByValue (array, value) {
   /*
-   *  log('transformEqualIndexFor')
+   *  log('findIndexByValue')
    */
 
+  const find = getFindByValue(value)
+
   return (
-    array.findIndex(getFindByValue(value))
+    array.findIndex(find)
   )
 }
 
 /**
- *  @param {string[] | number[] | object[] | boolean[] | null[]} array
- *  @param {string | number | object | boolean | null} [value]
+ *  @param {MemberArrayType} array
+ *  @param {MemberType} [value]
  *  @returns {string}
  */
-export function transformEqualIndexFor (array, value) {
+export function transformIndexToValueByFindEqual (array, value) {
   /*
-   *  log('transformEqualIndexFor')
+   *  log('transformIndexToValueByFindEqual')
    */
 
-  const find = getFindByEqual(value)
-
-  if (array.some(find)) {
-    const index = array.findIndex(find)
-
-    /*
-     *  Transform a number to a string
-     */
-    return String(index)
-  }
+  const index = findIndexByEqual(array, value)
 
   /*
-   *  Takes the place of `toString(document)` in `transform()`
-   */
-  return toString(value)
+    *  Transform a number to a string
+    */
+  return String(index)
 }
 
 /**
- *  @param {string[] | number[] | object[] | boolean[] | null[]} array
- *  @param {string | number | object | boolean | null} [value]
+ *  @param {MemberArrayType} array
+ *  @param {MemberType} [value]
  *  @returns {string}
  */
-export function getIndexByEqual (array, value) {
+export function findIndexByEqual (array, value) {
   /*
-   *  log('transformEqualIndexFor')
+   *  log('findIndexByEqual')
    */
 
+  const find = getFindByEqual(value)
+
   return (
-    array.findIndex(getFindByEqual(value))
+    array.findIndex(find)
   )
 }
 
@@ -633,113 +620,6 @@ export function getValue (values = {}, uri = '#', schema = {}) {
   return ''
 }
 
-/**
- *  @deprecated
- *
- *  @param {string | number} v
- *  @param {{ enum?: ItemsType }} [schema]
- *  @returns {string}
- */
-export function getValueForEnum (v, { enum: items = [] } = {}) {
-  if (v in items) { // @ts-ignore // if (Reflect.has(items, v)) {
-    const enumValue = items[v] // Reflect.get(items, v)
-
-    return String(enumValue)
-  }
-
-  return ''
-}
-
-/**
- *  Use `index` `item` `arrayIndex`
- *
- *  @deprecated
- */
-export function getIndexForEnum (values = {}, parentUri = '#', uri = '#', schema = {}) {
-  if (/\/\d+$/.test(uri)) {
-    /*
-     *  Get the index
-     */
-    return Number(uri.slice(uri.lastIndexOf('/') + 1))
-  }
-
-  return NaN
-}
-
-/**
- *  @deprecated
- *
- *  @param {string | number} v
- *  @param {{ anyOf?: ItemsType }} [schema]
- *  @returns {string}
- */
-export function getValueForAnyOf (v, { anyOf: items = [] } = {}) {
-  if (v in items) { // @ts-ignore // if (Reflect.has(items, v)) {
-    const anyOf = items[v] // Reflect.get(items, v)
-
-    const anyOfValue = transformToValue(anyOf)
-
-    if (isPrimitive(anyOfValue)) {
-      return String(anyOfValue)
-    }
-  }
-
-  return ''
-}
-
-/**
- *  Use `index` `item` `arrayIndex`
- *
- *  @deprecated
- */
-export function getIndexForAnyOf (values = {}, parentUri = '#', uri = '#', schema = {}) {
-  if (/\/\d+$/.test(uri)) {
-    /*
-     *  Get the index
-     */
-    return Number(uri.slice(uri.lastIndexOf('/') + 1))
-  }
-
-  return NaN
-}
-
-/**
- *  @deprecated
- *
- *  @param {string | number} v
- *  @param {{ oneOf?: ItemsType }} [schema]
- *  @returns {string}
- */
-export function getValueForOneOf (v, { oneOf: items = [] } = {}) {
-  if (v in items) { // @ts-ignore // if (Reflect.has(items, v)) {
-    const oneOf = items[v] // Reflect.get(items, v)
-
-    const oneOfValue = transformToValue(oneOf)
-
-    if (isPrimitive(oneOfValue)) {
-      return String(oneOfValue)
-    }
-  }
-
-  return ''
-}
-
-/**
- *  Use `index` `item` `arrayIndex`
- *
- *  @deprecated
- */
-export function getIndexForOneOf (values = {}, parentUri = '#', uri = '#', schema = {}) {
-  if (/\/\d+$/.test(uri)) {
-    /*
-     *  Get the index
-     */
-    return Number(uri.slice(uri.lastIndexOf('/') + 1))
-  }
-
-  return NaN
-}
-
 /**
  *  @param {ParamsType} [params]
  *  @param {string} [uri]
@@ -902,98 +782,98 @@ export function getElementsFieldValue (values = {}, uri = '#', schema = {}) {
 }
 
 /**
- *  @param {{ 'enum'?: ItemsType }} [schema]
- *  @returns {schema is { 'enum': ItemsType }}
+ *  @param {{ 'enum'?: MemberArrayType }} [schema]
+ *  @returns {schema is { 'enum': MemberArrayType }}
  */
 export const hasEnum = (schema = {}) => 'enum' in schema // Reflect.has(schema, 'enum')
 
 /**
  *  @overload
- *  @param {{ 'enum': ItemsType }} schema
- *  @returns {ItemsType}
+ *  @param {{ 'enum': MemberArrayType }} schema
+ *  @returns {MemberArrayType}
  *
- *  @param {{ 'enum'?: ItemsType }} [schema]
- *  @returns {ItemsType | undefined}
+ *  @param {{ 'enum'?: MemberArrayType }} [schema]
+ *  @returns {MemberArrayType | undefined}
  */
 export const getEnum = (schema = {}) => schema.enum // Reflect.get(schema, 'enum')
 
 /**
- *  @param {{ 'const'?: string | number | object | boolean | null }} [schema]
- *  @returns {schema is { 'const': string | number | object | boolean | null }}
+ *  @param {{ 'const'?: MemberType }} [schema]
+ *  @returns {schema is { 'const': MemberType }}
  */
 export const hasConst = (schema = {}) => 'const' in schema // Reflect.has(schema, 'const')
 
 /**
  *  @overload
- *  @param {{ 'const': string | number | object | boolean | null }} schema
- *  @returns {string | number | object | boolean | null}
+ *  @param {{ 'const': MemberType }} schema
+ *  @returns {MemberType}
  *
- *  @param {{ 'const'?: string | number | object | boolean | null }} [schema]
- *  @returns {string | number | object | boolean | null | undefined}
+ *  @param {{ 'const'?: MemberType }} [schema]
+ *  @returns {MemberType | undefined}
  */
 export const getConst = (schema = {}) => schema.const // Reflect.get(schema, 'const')
 
 /**
- *  @param {{ 'default'?: string | number | object | boolean | null }} [schema]
- *  @returns {schema is { 'default': string | number | object | boolean | null }}
+ *  @param {{ 'default'?: MemberType }} [schema]
+ *  @returns {schema is { 'default': MemberType }}
  */
 export const hasDefault = (schema = {}) => 'default' in schema // Reflect.has(schema, 'default')
 
 /**
  *  @overload
- *  @param {{ 'default': string | number | object | boolean | null }} schema
- *  @returns {string | number | object | boolean | null}
+ *  @param {{ 'default': MemberType }} schema
+ *  @returns {MemberType}
  *
- *  @param {{ 'default'?: string | number | object | boolean | null }} [schema]
- *  @returns {string | number | object | boolean | null | undefined}
+ *  @param {{ 'default'?: MemberType }} [schema]
+ *  @returns {MemberType | undefined}
  */
 export const getDefault = (schema = {}) => schema.default // Reflect.get(schema, 'default')
 
 /**
- *  @param {{ 'anyOf'?: ItemsType }} [schema]
- *  @returns {schema is { 'anyOf': ItemsType }}
+ *  @param {{ 'anyOf'?: MemberArrayType }} [schema]
+ *  @returns {schema is { 'anyOf': MemberArrayType }}
  */
 export const hasAnyOf = (schema = {}) => 'anyOf' in schema // Reflect.has(schema, 'anyOf')
 
 /**
  *  @overload
- *  @param {{ 'anyOf': ItemsType }} schema
- *  @returns {ItemsType}
+ *  @param {{ 'anyOf': MemberArrayType }} schema
+ *  @returns {MemberArrayType}
  *
- *  @param {{ 'anyOf'?: ItemsType }} [schema]
- *  @returns {ItemsType | undefined}
+ *  @param {{ 'anyOf'?: MemberArrayType }} [schema]
+ *  @returns {MemberArrayType | undefined}
  */
 export const getAnyOf = (schema = {}) => schema.anyOf // Reflect.get(schema, 'anyOf')
 
 /**
- *  @param {{ 'oneOf'?: ItemsType }} [schema]
- *  @returns {schema is { 'oneOf': ItemsType }}
+ *  @param {{ 'oneOf'?: MemberArrayType }} [schema]
+ *  @returns {schema is { 'oneOf': MemberArrayType }}
  */
 export const hasOneOf = (schema = {}) => 'oneOf' in schema // Reflect.has(schema, 'oneOf')
 
 /**
  *  @overload
- *  @param {{ 'oneOf': ItemsType }} schema
- *  @returns {ItemsType}
+ *  @param {{ 'oneOf': MemberArrayType }} schema
+ *  @returns {MemberArrayType}
  *
- *  @param {{ 'oneOf'?: ItemsType }} schema
- *  @returns {ItemsType | undefined}
+ *  @param {{ 'oneOf'?: MemberArrayType }} schema
+ *  @returns {MemberArrayType | undefined}
  */
 export const getOneOf = (schema = {}) => schema.oneOf // Reflect.get(schema, 'oneOf')
 
 /**
- *  @param {{ 'allOf'?: ItemsType }} [schema]
- *  @returns {schema is { 'allOf': ItemsType }}
+ *  @param {{ 'allOf'?: MemberArrayType }} [schema]
+ *  @returns {schema is { 'allOf': MemberArrayType }}
  */
 export const hasAllOf = (schema = {}) => 'allOf' in schema // Reflect.has(schema, 'allOf')
 
 /**
  *  @overload
- *  @param {{ 'allOf': ItemsType }} schema
- *  @returns {ItemsType}
+ *  @param {{ 'allOf': MemberArrayType }} schema
+ *  @returns {MemberArrayType}
  *
- *  @param {{ 'allOf'?: ItemsType }} [schema]
- *  @returns {ItemsType | undefined}
+ *  @param {{ 'allOf'?: MemberArrayType }} [schema]
+ *  @returns {MemberArrayType | undefined}
  */
 export const getAllOf = (schema = {}) => schema.allOf // Reflect.get(schema, 'allOf')