Options
All
  • Public
  • Public/Protected
  • All
Menu

Class AreaPlotTrait<X, Y>

Type parameters

  • X = unknown

  • Y = unknown

Hierarchy

Index

Constructors

Properties

Accessors

Methods

Constructors

constructor

Properties

Optional Readonly consumerType

consumerType: Class<Consumer<Consumable>>

Readonly consumers

consumers: readonly Consumer<Consumable>[]

Readonly dataSet

dataSet: TraitRef<AreaPlotTrait<X, Y>, DataSetTrait<X, Y>>

Readonly decoherent

decoherent: null | readonly Fastener<unknown>[]

Readonly fasteners

fasteners: null | {}

Readonly fill

fill: Property<AreaPlotTrait<X, Y>, null | Color | Look<Color, never>, null | AnyColor | Look<Color, never>>

Readonly flags

flags: number

Readonly key

key: undefined | string

Readonly model

model: null | Model

Optional Readonly observerType

observerType: Class<AreaPlotTraitObserver<X, Y, AreaPlotTrait<X, Y>>>

Readonly observers

observers: readonly AreaPlotTraitObserver<X, Y, AreaPlotTrait<X, Y>>[]

Readonly uid

uid: number

Readonly warpProvider

warpProvider: WarpProvider<AreaPlotTrait<X, Y>, WarpService<AreaPlotTrait<X, Y>>>

Readonly warpRef

warpRef: Property<AreaPlotTrait<X, Y>, null | WarpRef, null | WarpRef>

Static Readonly ConsumingFlag

ConsumingFlag: number

Static Readonly FlagMask

FlagMask: number

Static Readonly FlagShift

FlagShift: number

Static Readonly InsertChildFlags

InsertChildFlags: number

Static Readonly InsertTraitFlags

InsertTraitFlags: number

Static Readonly MountFlags

MountFlags: number

Static Readonly MountedFlag

MountedFlag: number

Static Readonly RemoveChildFlags

RemoveChildFlags: number

Static Readonly RemoveTraitFlags

RemoveTraitFlags: number

Static Readonly StartConsumingFlags

StartConsumingFlags: number

Static Readonly StopConsumingFlags

StopConsumingFlags: number

Static Readonly dataSet

dataSet: FastenerClass<TraitRef<PlotTrait<unknown, unknown>, DataSetTrait<unknown, unknown>>>

Static uid

uid: () => number

Type declaration

    • (): number

    • Returns number

Accessors

analyzing

  • get analyzing(): boolean

  • Returns boolean

childCount

  • get childCount(): number

  • Returns number

children

  • get children(): readonly Model[]

  • Returns readonly Model[]

consuming

  • get consuming(): boolean

  • Returns boolean

insertChildFlags

  • get insertChildFlags(): number

  • Returns number

insertTraitFlags

  • get insertTraitFlags(): number

  • Returns number

modelContext

modelFlags

  • get modelFlags(): number

  • Returns number

mountFlags

  • get mountFlags(): number

  • Returns number

mounted

  • get mounted(): boolean

  • Returns boolean

parent

  • get parent(): null | Model

  • Returns null | Model

refreshing

  • get refreshing(): boolean

  • Returns boolean

removeChildFlags

  • get removeChildFlags(): number

  • Returns number

removeTraitFlags

  • get removeTraitFlags(): number

  • Returns number

startConsumingFlags

  • get startConsumingFlags(): number

  • Returns number

stopConsumingFlags

  • get stopConsumingFlags(): number

  • Returns number

traitCount

  • get traitCount(): number

  • Returns number

traits

  • get traits(): readonly Trait[]

  • Returns readonly Trait[]

traversing

  • get traversing(): boolean

  • Returns boolean

updating

  • get updating(): boolean

  • Returns boolean

Methods

analyzeChildren

  • analyzeChildren(analyzeFlags: number, modelContext: ModelContext, analyzeChildModel: (child: Model, analyzeFlags: number, modelContext: ModelContext) => void, analyzeChildren: (analyzeFlags: number, modelContext: ModelContext, analyzeChildModel: (child: Model, analyzeFlags: number, modelContext: ModelContext) => void) => void): void

  • Parameters

    • analyzeFlags: number
    • modelContext: ModelContext
    • analyzeChildModel: (child: Model, analyzeFlags: number, modelContext: ModelContext) => void
    • analyzeChildren: (analyzeFlags: number, modelContext: ModelContext, analyzeChildModel: (child: Model, analyzeFlags: number, modelContext: ModelContext) => void) => void
        • (analyzeFlags: number, modelContext: ModelContext, analyzeChildModel: (child: Model, analyzeFlags: number, modelContext: ModelContext) => void): void

        • Parameters

          Returns void

    Returns void

appendChild

  • appendChild<M>(child: M, key?: string): M
  • appendChild<F>(factory: F, key?: string): InstanceType<F>
  • appendChild(child: AnyModel<Model>, key?: string): Model

  • Type parameters

    Parameters

    • child: M
    • Optional key: string

    Returns M

  • Type parameters

    • F: new (...args: any[]) => InstanceType<F> & Creatable<InstanceType<F>, F>

    Parameters

    • factory: F
    • Optional key: string

    Returns InstanceType<F>

  • Parameters

    Returns Model

appendTrait

  • appendTrait<T>(trait: T, key?: string): T
  • appendTrait<F>(factory: F, key?: string): InstanceType<F>
  • appendTrait(trait: AnyTrait<Trait>, key?: string): Trait

  • Type parameters

    Parameters

    • trait: T
    • Optional key: string

    Returns T

  • Type parameters

    • F: new (...args: any[]) => InstanceType<F> & Creatable<InstanceType<F>, F>

    Parameters

    • factory: F
    • Optional key: string

    Returns InstanceType<F>

  • Parameters

    Returns Trait

Protected attachFastener

  • attachFastener(fastenerName: string, fastener: Fastener<unknown>): void

  • Parameters

    • fastenerName: string
    • fastener: Fastener<unknown>

    Returns void

attachModel

  • attachModel(model: Model): void

  • Parameters

    Returns void

Protected bindChildFastener

  • bindChildFastener(fastener: Fastener<unknown>, child: Model, target: null | Model): void

Protected bindChildFasteners

  • bindChildFasteners(child: Model, target: null | Model): void

Protected bindFastener

  • bindFastener(fastener: Fastener<unknown>): void

  • Parameters

    Returns void

Protected bindModelFasteners

  • bindModelFasteners(model: Model): void

Protected bindTraitFastener

  • bindTraitFastener(fastener: Fastener<unknown>, trait: Trait, target: null | Trait): void

Protected bindTraitFasteners

  • bindTraitFasteners(trait: Trait, target: null | Trait): void

callObservers

  • Type parameters

    • O

    • K: string | number | symbol

    Parameters

    Returns void

consume

decohereFastener

  • decohereFastener(fastener: Fastener<unknown>): void

Protected detachFastener

  • detachFastener(fastenerName: string, fastener: Fastener<unknown>): void

  • Parameters

    • fastenerName: string
    • fastener: Fastener<unknown>

    Returns void

detachModel

  • detachModel(model: Model): void

  • Parameters

    Returns void

Protected detectDataSetTrait

Protected detectTraits

  • detectTraits(model: Model): void

  • Parameters

    Returns void

didAggregate

didAnalyze

  • didAnalyze(analyzeFlags: number, modelContext: ModelContext): void

  • Parameters

    Returns void

Protected didAttachFastener

  • didAttachFastener(fastenerName: string, fastener: Fastener<unknown>): void

  • Parameters

    • fastenerName: string
    • fastener: Fastener<unknown>

    Returns void

Protected didAttachModel

  • didAttachModel(model: Model): void

didAttachParent

  • didAttachParent(parent: Model): void

Protected didConsume

didCorrelate

Protected didDetachFastener

  • didDetachFastener(fastenerName: string, fastener: Fastener<unknown>): void

  • Parameters

    • fastenerName: string
    • fastener: Fastener<unknown>

    Returns void

Protected didDetachModel

  • didDetachModel(model: Model): void

didDetachParent

  • didDetachParent(parent: Model): void

didInsertChild

  • didInsertChild(child: Model, target: null | Model): void

didInsertTrait

  • didInsertTrait(trait: Trait, target: null | Trait): void

Protected didMount

  • didMount(): void

  • Returns void

didMutate

Protected didObserve

didReconcile

didRefresh

  • didRefresh(refreshFlags: number, modelContext: ModelContext): void

  • Parameters

    Returns void

didRemoveChild

  • didRemoveChild(child: Model): void

didRemoveTrait

  • didRemoveTrait(trait: Trait): void

Protected didStartConsuming

  • didStartConsuming(): void

Protected didStopConsuming

  • didStopConsuming(): void

Protected didUnconsume

Protected didUnmount

  • didUnmount(): void

  • Returns void

Protected didUnobserve

didValidate

equals

  • equals(that: unknown): boolean

  • Parameters

    • that: unknown

    Returns boolean

firstChild

  • firstChild(): null | Model

firstTrait

  • firstTrait(): null | Trait

forEachChild

  • forEachChild<T>(callback: (child: Model) => void | T): undefined | T
  • forEachChild<T, S>(callback: (child: Model) => void | T, thisArg: S): undefined | T

  • Type parameters

    • T

    Parameters

    • callback: (child: Model) => void | T
        • (child: Model): void | T

        • Parameters

          Returns void | T

    Returns undefined | T

  • Type parameters

    • T

    • S

    Parameters

    • callback: (child: Model) => void | T
        • (child: Model): void | T

        • Parameters

          Returns void | T

    • thisArg: S

    Returns undefined | T

Protected forEachObserver

forEachTrait

  • forEachTrait<T>(callback: (trait: Trait) => void | T): undefined | T
  • forEachTrait<T, S>(callback: (trait: Trait) => void | T, thisArg: S): undefined | T

  • Type parameters

    • T

    Parameters

    • callback: (trait: Trait) => void | T
        • (trait: Trait): void | T

        • Parameters

          Returns void | T

    Returns undefined | T

  • Type parameters

    • T

    • S

    Parameters

    • callback: (trait: Trait) => void | T
        • (trait: Trait): void | T

        • Parameters

          Returns void | T

    • thisArg: S

    Returns undefined | T

getBase

  • getBase<F>(baseBound: F): null | InstanceType<F>

  • Type parameters

    • F: new (...args: any[]) => Model

    Parameters

    • baseBound: F

    Returns null | InstanceType<F>

getBaseTrait

  • getBaseTrait<F>(baseBound: F): null | InstanceType<F>

  • Type parameters

    • F: new (...args: any[]) => Trait

    Parameters

    • baseBound: F

    Returns null | InstanceType<F>

getChild

  • getChild<F>(key: string, childBound: F): null | InstanceType<F>
  • getChild(key: string, childBound?: new (...args: any[]) => Model): null | Model

  • Type parameters

    • F: new (...args: any[]) => Model

    Parameters

    • key: string
    • childBound: F

    Returns null | InstanceType<F>

  • Parameters

    • key: string
    • Optional childBound: new (...args: any[]) => Model
        • new (...args: any[]): Model

        • Parameters

          • Rest ...args: any[]

          Returns Model

    Returns null | Model

getFastener

  • getFastener<F>(fastenerName: string, fastenerBound: Class<F>): null | F
  • getFastener(fastenerName: string, fastenerBound?: null | Class<Fastener<unknown>>): null | Fastener<unknown>

  • Type parameters

    Parameters

    • fastenerName: string
    • fastenerBound: Class<F>

    Returns null | F

  • Parameters

    • fastenerName: string
    • Optional fastenerBound: null | Class<Fastener<unknown>>

    Returns null | Fastener<unknown>

getLazyFastener

  • getLazyFastener<F>(fastenerName: string, fastenerBound: Class<F>): null | F
  • getLazyFastener(fastenerName: string, fastenerBound?: null | Class<Fastener<unknown>>): null | Fastener<unknown>

  • Type parameters

    Parameters

    • fastenerName: string
    • fastenerBound: Class<F>

    Returns null | F

  • Parameters

    • fastenerName: string
    • Optional fastenerBound: null | Class<Fastener<unknown>>

    Returns null | Fastener<unknown>

getSuper

  • getSuper<F>(superBound: F): null | InstanceType<F>

  • Type parameters

    • F: new (...args: any[]) => Model

    Parameters

    • superBound: F

    Returns null | InstanceType<F>

getSuperFastener

  • getSuperFastener<F>(fastenerName: string, fastenerBound: Class<F>): null | F
  • getSuperFastener(fastenerName: string, fastenerBound?: null | Class<Fastener<unknown>>): null | Fastener<unknown>

  • Type parameters

    Parameters

    • fastenerName: string
    • fastenerBound: Class<F>

    Returns null | F

  • Parameters

    • fastenerName: string
    • Optional fastenerBound: null | Class<Fastener<unknown>>

    Returns null | Fastener<unknown>

getSuperTrait

  • getSuperTrait<F>(superBound: F): null | InstanceType<F>

  • Type parameters

    • F: new (...args: any[]) => Trait

    Parameters

    • superBound: F

    Returns null | InstanceType<F>

getTrait

  • getTrait<F>(key: string, traitBound: F): null | InstanceType<F>
  • getTrait(key: string, traitBound?: new (...args: any[]) => Trait): null | Trait
  • getTrait<F>(traitBound: F): null | InstanceType<F>

  • Type parameters

    • F: new (...args: any[]) => Trait

    Parameters

    • key: string
    • traitBound: F

    Returns null | InstanceType<F>

  • Parameters

    • key: string
    • Optional traitBound: new (...args: any[]) => Trait
        • new (...args: any[]): Trait

        • Parameters

          • Rest ...args: any[]

          Returns Trait

    Returns null | Trait

  • Type parameters

    • F: new (...args: any[]) => Trait

    Parameters

    • traitBound: F

    Returns null | InstanceType<F>

hasFastener

  • hasFastener(fastenerName: string, fastenerBound?: null | Class<Fastener<unknown>>): boolean

  • Parameters

    • fastenerName: string
    • Optional fastenerBound: null | Class<Fastener<unknown>>

    Returns boolean

hashCode

  • hashCode(): number

  • Returns number

init

  • Parameters

    Returns void

insertChild

  • insertChild<M>(child: M, target: null | Model, key?: string): M
  • insertChild<F>(factory: F, target: null | Model, key?: string): InstanceType<F>
  • insertChild(child: AnyModel<Model>, target: null | Model, key?: string): Model

  • Type parameters

    Parameters

    • child: M
    • target: null | Model
    • Optional key: string

    Returns M

  • Type parameters

    • F: new (...args: any[]) => InstanceType<F> & Creatable<InstanceType<F>, F>

    Parameters

    • factory: F
    • target: null | Model
    • Optional key: string

    Returns InstanceType<F>

  • Parameters

    Returns Model

insertTrait

  • insertTrait<T>(trait: T, target: null | Trait, key?: string): T
  • insertTrait<F>(factory: F, target: null | Trait, key?: string): InstanceType<F>
  • insertTrait(trait: AnyTrait<Trait>, target: null | Trait, key?: string): Trait

  • Type parameters

    Parameters

    • trait: T
    • target: null | Trait
    • Optional key: string

    Returns T

  • Type parameters

    • F: new (...args: any[]) => InstanceType<F> & Creatable<InstanceType<F>, F>

    Parameters

    • factory: F
    • target: null | Trait
    • Optional key: string

    Returns InstanceType<F>

  • Parameters

    Returns Trait

lastChild

  • lastChild(): null | Model

lastTrait

  • lastTrait(): null | Trait

Protected mountFasteners

  • mountFasteners(): void

mountTrait

  • mountTrait(): void

  • Returns void

needsAnalyze

  • needsAnalyze(analyzeFlags: number, modelContext: ModelContext): number

  • Parameters

    Returns number

needsRefresh

  • needsRefresh(refreshFlags: number, modelContext: ModelContext): number

  • Parameters

    Returns number

needsUpdate

  • needsUpdate(updateFlags: number, immediate: boolean): number

  • Parameters

    • updateFlags: number
    • immediate: boolean

    Returns number

nextChild

nextTrait

observe

onAggregate

onAnalyze

  • onAnalyze(analyzeFlags: number, modelContext: ModelContext): void

  • Parameters

    Returns void

Protected onAttachFastener

  • onAttachFastener(fastenerName: string, fastener: Fastener<unknown>): void

  • Parameters

    • fastenerName: string
    • fastener: Fastener<unknown>

    Returns void

Protected onAttachModel

  • onAttachModel(model: Model): void

  • Parameters

    Returns void

onAttachParent

  • onAttachParent(parent: Model): void

Protected onConsume

onCorrelate

Protected onDetachFastener

  • onDetachFastener(fastenerName: string, fastener: Fastener<unknown>): void

  • Parameters

    • fastenerName: string
    • fastener: Fastener<unknown>

    Returns void

Protected onDetachModel

  • onDetachModel(model: Model): void

onDetachParent

  • onDetachParent(parent: Model): void

onInsertChild

  • onInsertChild(child: Model, target: null | Model): void

onInsertTrait

  • onInsertTrait(trait: Trait, targetTrait: null | Trait): void

  • Parameters

    Returns void

Protected onMount

  • onMount(): void

  • Returns void

onMutate

Protected onObserve

onReconcile

onRefresh

  • onRefresh(refreshFlags: number, modelContext: ModelContext): void

  • Parameters

    Returns void

onRemoveChild

  • onRemoveChild(child: Model): void

onRemoveTrait

  • onRemoveTrait(trait: Trait): void

  • Parameters

    Returns void

Protected onStartConsuming

  • onStartConsuming(): void

Protected onStopConsuming

  • onStopConsuming(): void

Protected onUnconsume

Protected onUnmount

  • onUnmount(): void

  • Returns void

Protected onUnobserve

onValidate

prependChild

  • prependChild<M>(child: M, key?: string): M
  • prependChild<F>(factory: F, key?: string): InstanceType<F>
  • prependChild(child: AnyModel<Model>, key?: string): Model

  • Type parameters

    Parameters

    • child: M
    • Optional key: string

    Returns M

  • Type parameters

    • F: new (...args: any[]) => InstanceType<F> & Creatable<InstanceType<F>, F>

    Parameters

    • factory: F
    • Optional key: string

    Returns InstanceType<F>

  • Parameters

    Returns Model

prependTrait

  • prependTrait<T>(trait: T, key?: string): T
  • prependTrait<F>(factory: F, key?: string): InstanceType<F>
  • prependTrait(trait: AnyTrait<Trait>, key?: string): Trait

  • Type parameters

    Parameters

    • trait: T
    • Optional key: string

    Returns T

  • Type parameters

    • F: new (...args: any[]) => InstanceType<F> & Creatable<InstanceType<F>, F>

    Parameters

    • factory: F
    • Optional key: string

    Returns InstanceType<F>

  • Parameters

    Returns Trait

previousChild

previousTrait

recohereDownlinks

  • recohereDownlinks(t: number): void

  • Parameters

    • t: number

    Returns void

recohereFasteners

  • recohereFasteners(t?: number): void

  • Parameters

    • Optional t: number

    Returns void

refreshChildren

  • refreshChildren(refreshFlags: number, modelContext: ModelContext, refreshChild: (child: Model, refreshFlags: number, modelContext: ModelContext) => void, refreshChildren: (refreshFlags: number, modelContext: ModelContext, refreshChild: (child: Model, refreshFlags: number, modelContext: ModelContext) => void) => void): void

remove

  • remove(): void

  • Returns void

removeChild

  • removeChild(key: string): null | Model
  • removeChild(child: Model): void

  • Parameters

    • key: string

    Returns null | Model

  • Parameters

    Returns void

removeTrait

  • removeTrait(key: string): null | Trait
  • removeTrait(trait: Trait): void

  • Parameters

    • key: string

    Returns null | Trait

  • Parameters

    Returns void

replaceChild

  • replaceChild<M>(newChild: Model, oldChild: M): M
  • replaceChild<M>(newChild: AnyModel<Model>, oldChild: M): M

  • Type parameters

    Parameters

    • newChild: Model
    • oldChild: M

    Returns M

  • Type parameters

    Parameters

    Returns M

replaceTraitt

  • replaceTraitt<T>(newTrait: Trait, oldTrait: T): T
  • replaceTraitt<T>(newTrait: AnyTrait<Trait>, oldTrait: T): T

requestUpdate

  • requestUpdate(target: Model, updateFlags: number, immediate: boolean): void

  • Parameters

    • target: Model
    • updateFlags: number
    • immediate: boolean

    Returns void

requireUpdate

  • requireUpdate(updateFlags: number, immediate?: boolean): void

  • Parameters

    • updateFlags: number
    • Optional immediate: boolean

    Returns void

setChild

  • setChild<M>(key: string, newChild: M): null | Model
  • setChild<F>(key: string, factory: F): null | Model
  • setChild(key: string, newChild: null | AnyModel<Model>): null | Model

  • Type parameters

    Parameters

    • key: string
    • newChild: M

    Returns null | Model

  • Type parameters

    • F: new (...args: any[]) => InstanceType<F> & Creatable<InstanceType<F>, F>

    Parameters

    • key: string
    • factory: F

    Returns null | Model

  • Parameters

    Returns null | Model

setFastener

  • setFastener(fastenerName: string, newFastener: null | Fastener<unknown>): void

  • Parameters

    • fastenerName: string
    • newFastener: null | Fastener<unknown>

    Returns void

setFlags

  • setFlags(flags: number): void

  • Parameters

    • flags: number

    Returns void

setKey

  • setKey(key: undefined | string): void

  • Parameters

    • key: undefined | string

    Returns void

setModelFlags

  • setModelFlags(modelFlags: number): void

  • Parameters

    • modelFlags: number

    Returns void

setTrait

  • setTrait<T>(key: string, newTrait: T): null | Trait
  • setTrait<F>(key: string, factory: F): null | Trait
  • setTrait(key: string, newTrait: null | AnyTrait<Trait>): null | Trait

  • Type parameters

    Parameters

    • key: string
    • newTrait: T

    Returns null | Trait

  • Type parameters

    • F: new (...args: any[]) => InstanceType<F> & Creatable<InstanceType<F>, F>

    Parameters

    • key: string
    • factory: F

    Returns null | Trait

  • Parameters

    Returns null | Trait

Protected startConsuming

  • startConsuming(): void

Protected startConsumingFasteners

  • startConsumingFasteners(): void

Protected stopConsuming

  • stopConsuming(): void

Protected stopConsumingFasteners

  • stopConsumingFasteners(): void

Protected unbindChildFastener

  • unbindChildFastener(fastener: Fastener<unknown>, child: Model): void

Protected unbindChildFasteners

  • unbindChildFasteners(child: Model): void

Protected unbindModelFasteners

  • unbindModelFasteners(model: Model): void

Protected unbindTraitFastener

  • unbindTraitFastener(fastener: Fastener<unknown>, trait: Trait): void

Protected unbindTraitFasteners

  • unbindTraitFasteners(trait: Trait): void

unconsume

Protected unmountFasteners

  • unmountFasteners(): void

unmountTrait

  • unmountTrait(): void

  • Returns void

unobserve

willAggregate

willAnalyze

  • willAnalyze(analyzeFlags: number, modelContext: ModelContext): void

  • Parameters

    Returns void

Protected willAttachFastener

  • willAttachFastener(fastenerName: string, fastener: Fastener<unknown>): void

Protected willAttachModel

  • willAttachModel(model: Model): void

willAttachParent

  • willAttachParent(parent: Model): void

Protected willConsume

willCorrelate

Protected willDetachFastener

  • willDetachFastener(fastenerName: string, fastener: Fastener<unknown>): void

Protected willDetachModel

  • willDetachModel(model: Model): void

willDetachParent

  • willDetachParent(parent: Model): void

willInsertChild

  • willInsertChild(child: Model, target: null | Model): void

willInsertTrait

  • willInsertTrait(trait: Trait, target: null | Trait): void

Protected willMount

  • willMount(): void

  • Returns void

willMutate

Protected willObserve

willReconcile

willRefresh

  • willRefresh(refreshFlags: number, modelContext: ModelContext): void

  • Parameters

    Returns void

willRemoveChild

  • willRemoveChild(child: Model): void

willRemoveTrait

  • willRemoveTrait(trait: Trait): void

Protected willStartConsuming

  • willStartConsuming(): void

Protected willStopConsuming

  • willStopConsuming(): void

Protected willUnconsume

Protected willUnmount

  • willUnmount(): void

  • Returns void

Protected willUnobserve

willValidate

Static create

  • create<S>(): InstanceType<S>

  • Type parameters

    • S: new () => InstanceType<S>

    Returns InstanceType<S>

Static fromAny

  • fromAny<S>(value: AnyTrait<InstanceType<S>>): InstanceType<S>

  • Type parameters

    • S: new (...args: any[]) => InstanceType<S>

    Parameters

    Returns InstanceType<S>

Static fromInit

  • fromInit<S>(init: InitType<InstanceType<S>>): InstanceType<S>

  • Type parameters

    • S: new (...args: any[]) => InstanceType<S>

    Parameters

    Returns InstanceType<S>

Generated using TypeDoc