@snap/camera-kit 0.7.0

package/docs/md/modules.md

@@ -0,0 +1,827 @@
+[CameraKit Web SDK - v0.7.0-alpha.1](README.md) / Exports
+
+# CameraKit Web SDK - v0.7.0-alpha.1
+
+## Table of contents
+
+### Classes
+
+- [CameraKit](classes/CameraKit.md)
+- [TypedCustomEvent](classes/TypedCustomEvent.md)
+- [TypedEventTarget](classes/TypedEventTarget.md)
+- [LensSources](classes/LensSources.md)
+- [LensRepository](classes/LensRepository.md)
+- [CameraKitSource](classes/CameraKitSource.md)
+- [CameraKitSession](classes/CameraKitSession.md)
+- [LensPerformanceMeasurement](classes/LensPerformanceMeasurement.md)
+- [LensPerformanceMetrics](classes/LensPerformanceMetrics.md)
+- [Transform2D](classes/Transform2D.md)
+
+### Interfaces
+
+- [CreateSessionOptions](interfaces/CreateSessionOptions.md)
+- [EstimatedLensPerformance](interfaces/EstimatedLensPerformance.md)
+- [CameraKitBootstrapConfiguration](interfaces/CameraKitBootstrapConfiguration.md)
+- [LensSource](interfaces/LensSource.md)
+- [UriHandler](interfaces/UriHandler.md)
+- [UriRequest](interfaces/UriRequest.md)
+- [UriResponse](interfaces/UriResponse.md)
+- [UriCancelRequest](interfaces/UriCancelRequest.md)
+- [Lens](interfaces/Lens.md)
+- [CameraKitSourceSubscriber](interfaces/CameraKitSourceSubscriber.md)
+- [MediaStreamSourceOptions](interfaces/MediaStreamSourceOptions.md)
+- [VideoSourceOptions](interfaces/VideoSourceOptions.md)
+- [ComputedFrameMetrics](interfaces/ComputedFrameMetrics.md)
+
+### Type Aliases
+
+- [LensMetricsEvents](modules.md#lensmetricsevents)
+- [LensPerformanceCluster](modules.md#lensperformancecluster)
+- [PublicContainer](modules.md#publiccontainer)
+- [UriHandlers](modules.md#urihandlers)
+- [Uri](modules.md#uri)
+- [LensLaunchParams](modules.md#lenslaunchparams)
+- [AssetTiming](modules.md#assettiming)
+- [AssetLoader](modules.md#assetloader)
+- [CameraKitDeviceInfo](modules.md#camerakitdeviceinfo)
+- [CameraKitSourceInfo](modules.md#camerakitsourceinfo)
+- [CameraKitSourceOptions](modules.md#camerakitsourceoptions)
+- [LensView](modules.md#lensview)
+- [LensWait](modules.md#lenswait)
+- [LegalError](modules.md#legalerror)
+- [LensContentValidationError](modules.md#lenscontentvalidationerror)
+- [LensError](modules.md#lenserror)
+- [CameraKitSourceError](modules.md#camerakitsourceerror)
+- [LensImagePickerError](modules.md#lensimagepickererror)
+- [CacheKeyNotFoundError](modules.md#cachekeynotfounderror)
+- [ConfigurationError](modules.md#configurationerror)
+- [WebGLError](modules.md#webglerror)
+- [BenchmarkError](modules.md#benchmarkerror)
+- [PlatformNotSupportedError](modules.md#platformnotsupportederror)
+- [LensExecutionError](modules.md#lensexecutionerror)
+- [PersistentStoreError](modules.md#persistentstoreerror)
+- [LensAssetError](modules.md#lensasseterror)
+- [BootstrapError](modules.md#bootstraperror)
+- [RenderTarget](modules.md#rendertarget)
+- [CameraKitSessionEvents](modules.md#camerakitsessionevents)
+- [CameraKitSessionEventListener](modules.md#camerakitsessioneventlistener)
+- [KeyboardEvents](modules.md#keyboardevents)
+- [Keyboard](modules.md#keyboard)
+
+### Variables
+
+- [extensionRequestContext](modules.md#extensionrequestcontext)
+
+### Functions
+
+- [estimateLensPerformance](modules.md#estimatelensperformance)
+- [bootstrapCameraKit](modules.md#bootstrapcamerakit)
+- [createExtension](modules.md#createextension)
+- [Injectable](modules.md#injectable)
+- [lensSourcesFactory](modules.md#lenssourcesfactory)
+- [uriHandlersFactory](modules.md#urihandlersfactory)
+- [getRequiredBootstrapURLs](modules.md#getrequiredbootstrapurls)
+- [createImageSource](modules.md#createimagesource)
+- [createUserMediaSource](modules.md#createusermediasource)
+- [createMediaStreamSource](modules.md#createmediastreamsource)
+- [createVideoSource](modules.md#createvideosource)
+
+## Bootstrapping and Configuration
+
+### LensPerformanceCluster
+
+Ƭ **LensPerformanceCluster**: ``0`` \| ``1`` \| ``2`` \| ``3`` \| ``4`` \| ``5`` \| ``6``
+
+___
+
+### PublicContainer
+
+Ƭ **PublicContainer**: `Container`<`PublicServices`\>
+
+For more advanced use-cases, this DI Container holds services for which a custom implementation may be provided by
+the application.
+
+___
+
+### ConfigurationError
+
+Ƭ **ConfigurationError**: `NamedError`<``"ConfigurationError"``\>
+
+Thrown by [bootstrapCameraKit](modules.md#bootstrapcamerakit) if provided configuration is invalid.
+
+___
+
+### PlatformNotSupportedError
+
+Ƭ **PlatformNotSupportedError**: `NamedError`<``"PlatformNotSupportedError"``\>
+
+Thrown by [bootstrapCameraKit](modules.md#bootstrapcamerakit) when the current platform is not supported by CameraKit.
+
+This can happen if the browser doesn't support a required feature (e.g. WebGL).
+
+___
+
+### BootstrapError
+
+Ƭ **BootstrapError**: `NamedError`<``"BootstrapError"``\>
+
+Thrown by [bootstrapCameraKit](modules.md#bootstrapcamerakit) if an error occurs during SDK initializion or while downloading the render
+engine WebAssembly.
+
+___
+
+### estimateLensPerformance
+
+▸ **estimateLensPerformance**(): `Promise`<[`EstimatedLensPerformance`](interfaces/EstimatedLensPerformance.md)\>
+
+Run benchmarks which attempt to predict expected lens performance, and assign a cluster (i.e. a performance rating)
+which the CameraKit SDK can use to optimize certain lenses.
+
+#### Returns
+
+`Promise`<[`EstimatedLensPerformance`](interfaces/EstimatedLensPerformance.md)\>
+
+A rating from 1-6, indicating expected Lens performance.
+
+___
+
+### bootstrapCameraKit
+
+▸ **bootstrapCameraKit**(`configuration`, `provide?`): `Promise`<[`CameraKit`](classes/CameraKit.md)\>
+
+Bootstrap CameraKit. This will download the WebAssembly code which powers CameraKit's rendering engine, and return
+an instance of [CameraKit](classes/CameraKit.md).
+
+CameraKit must be provided with some configuration (the application's API token), and there are some additional
+configurations which are optional.
+
+Descriptions of the available configurations can be found in the documentation for
+[CameraKitBootstrapConfiguration](interfaces/CameraKitBootstrapConfiguration.md)
+
+---
+
+There is also a second, more advanced way to modify CameraKit to provide greater flexibility to support less common
+use cases.
+
+This requires some knowledge of CameraKit's dependency injection system, and allows applications to provide their
+own custom implementations of certain CameraKit components. This functionality will only be needed by applications
+with very specific, more advanced requirements.
+
+**`Example`**
+
+```ts
+// The most common way to bootstrap:
+const cameraKit = await bootstrapCameraKit({ apiToken: myApiToken })
+
+// For special advanced use-cases, it is possible to provide custom implementations for certain CameraKit components.
+const cameraKit = await bootstrapCameraKit(config, (container) => {
+  return container.provides(myCustomRemoteMediaAssetLoaderFactory)
+})
+```
+
+**`Throws`**
+
+- [ConfigurationError](modules.md#configurationerror) when provided configuration object is invalid
+ - [PlatformNotSupportedError](modules.md#platformnotsupportederror) when current platform is not supported by CameraKit
+ - [BootstrapError](modules.md#bootstraperror) when a failure occurs while initializing CameraKit and downloading the render engine
+WebAssembly binary.
+
+#### Parameters
+
+| Name | Type | Description |
+| :------ | :------ | :------ |
+| `configuration` | [`CameraKitBootstrapConfiguration`](interfaces/CameraKitBootstrapConfiguration.md) | Configure CameraKit with e.g. credentials, global resource endpoints, etc. |
+| `provide?` | (`c`: [`PublicContainer`](modules.md#publiccontainer)) => [`PublicContainer`](modules.md#publiccontainer) | Optional function that can make modifications to CameraKit's root DI container. |
+
+#### Returns
+
+`Promise`<[`CameraKit`](classes/CameraKit.md)\>
+
+A [CameraKit](classes/CameraKit.md) instance, which is the entry point to CameraKit's API.
+
+___
+
+### createExtension
+
+▸ **createExtension**(): `PartialContainer`
+
+Extensions offer a way to provide custom implementations of certain parts of the CameraKit SDK.
+
+This enables more advanced use-cases, in which the default behavior of the SDK is substantially altered. For example,
+replacing the default implementation that loads remote lens assets with a custom implementation that returns
+different assets based on some business logic within the application.
+
+An extension is implemented as a [PartialContainer] – a collection of factory functions, each with its own
+dependencies, which each provide some "Service." A Service can be of any type, and the CameraKit SDK defines its
+own Services, some of which can be overridden by providing a custom implementation of the type via an extension.
+
+Here's an example of how extensions might be used:
+```ts
+import { bootstrapCameraKit, createExtension, remoteMediaAssetLoaderFactory } from '@snap/camera-kit'
+
+const myCustomRemoteAssetLoader = Injectable(
+  remoteMediaAssetLoaderFactory.token,
+  [remoteMediaAssetLoaderFactory.token] as const,
+  (defaultLoader: AssetLoader): AssetLoader => {
+    return async (asset, lens) => {
+      if (lens?.id === MY_SPECIAL_LENS) {
+        return (await fetch('my/asset.glb')).arrayBuffer()
+      }
+      return defaultLoader(asset, lens)
+    }
+  },
+)
+
+const myExtension = createExtension().provides(myCustomeRemoteAssetLoader)
+const cameraKit = bootstrapCameraKit(config, container => container.provides(myExtension))
+```
+
+This also enables greater modularity – the person/team creating the extension can do so in their own package, which
+could be shared by many applications that all require the same functionality.
+
+#### Returns
+
+`PartialContainer`
+
+A PartialContainer which can be used to create a collection of Services, and can later be provided
+to CameraKit's DI container during [bootstrapCameraKit](modules.md#bootstrapcamerakit).
+
+___
+
+### getRequiredBootstrapURLs
+
+▸ **getRequiredBootstrapURLs**(`endpointOverride?`): `Promise`<`string`[]\>
+
+Returns a list of URLs for resources which will be fetched during [bootstrapCameraKit](modules.md#bootstrapcamerakit).
+
+When CameraKit is used on a website, these URLs much be reachable in order for CameraKit to be successfully
+bootstrapped.
+
+#### Parameters
+
+| Name | Type | Description |
+| :------ | :------ | :------ |
+| `endpointOverride?` | `string` | Optional endpoint override to load the assets from. |
+
+#### Returns
+
+`Promise`<`string`[]\>
+
+An array of asset URLs.
+
+## Lenses
+
+### LensMetricsEvents
+
+Ƭ **LensMetricsEvents**: [`TypedCustomEvent`](classes/TypedCustomEvent.md)<[`LensView`](modules.md#lensview)[``"name"``], [`LensView`](modules.md#lensview)\> \| [`TypedCustomEvent`](classes/TypedCustomEvent.md)<[`LensWait`](modules.md#lenswait)[``"name"``], [`LensWait`](modules.md#lenswait)\>
+
+Lens metrics events.
+
+These events are emitted by [CameraKit](classes/CameraKit.md) to report lens usage, performance, apply latency, etc.
+
+___
+
+### LensLaunchParams
+
+Ƭ **LensLaunchParams**: `Record`<`string`, `string` \| `number` \| `string`[] \| `number`[]\>
+
+Various lenses may support the passing of certain parameters from the application to the lens when it is launched.
+
+___
+
+### AssetTiming
+
+Ƭ **AssetTiming**: keyof typeof `assetTimingMap`
+
+Lens assets are included in a manifest, and each will indicate when that asset will be used by the lens.
+
+Assets can have the following timing values:
+- `required`: the lens will definitely request this asset immediately when the lens is applied.
+- `onDemand`: the lens may request this asset at some time while the lens is applied.
+
+Depending on the use-case, an application may want to cache both required and onDemand assets for
+a particular lens, or may decide to only cache required assets (or cache no assets).
+
+___
+
+### AssetLoader
+
+Ƭ **AssetLoader**: (`asset`: `AssetDescriptor`, `lens?`: [`Lens`](interfaces/Lens.md), `assetManifest?`: `LensAssetManifestItem`[]) => `Promise`<`AssetResponse`\> \| `AssetResponse`
+
+#### Type declaration
+
+▸ (`asset`, `lens?`, `assetManifest?`): `Promise`<`AssetResponse`\> \| `AssetResponse`
+
+An AssetLoader is used to retrieve assets. A separate loader may be defined to retrieve different asset types.
+
+##### Parameters
+
+| Name | Type |
+| :------ | :------ |
+| `asset` | `AssetDescriptor` |
+| `lens?` | [`Lens`](interfaces/Lens.md) |
+| `assetManifest?` | `LensAssetManifestItem`[] |
+
+##### Returns
+
+`Promise`<`AssetResponse`\> \| `AssetResponse`
+
+___
+
+### LensView
+
+Ƭ **LensView**: `MakeTaggedBusinessEvent`<``"lensView"``\>
+
+The LensView metric is emitted after a lens has been viewed (for longer than 100ms), when the lens is turned off.
+
+It contains information about rendering performance.
+
+Notes:
+  - If the page is hidden (e.g. user switches to a different tab, or application, or closes the tab, or closes the
+    browser, navigates to a new page, refreshes, etc.) this metric will be emitted at that time. This is to ensure
+    we don't lose the metric if the page is closed.
+  - If the page is hidden and then made visible again later (e.g. user switches to a different tab, then back), we
+    will begin measuring a new LensView. That is, we will not capture the time when the page is hidden even if the
+    lens is still rendering in the background.
+
+___
+
+### LensWait
+
+Ƭ **LensWait**: `MakeTaggedBusinessEvent`<``"lensWait"``\>
+
+The LensWait metric measures the time spent downloading the lens content and required assets. It gives an indication
+of the real UX impact of download latency. If lens content and assets are pre-loaded, the latency measured here
+should decrease – we measure between the request to apply a lens and when the lens is ready to render.
+
+___
+
+### RenderTarget
+
+Ƭ **RenderTarget**: ``"live"`` \| ``"capture"``
+
+Enumerates the supported render targets.
+
+Lenses may render to different render targets, as designed by the lens creator. In CameraKit, it's possible to choose
+which render target to render, and the result for each target is available as a separate `<canvas>` element.
+
+___
+
+### CameraKitSessionEvents
+
+Ƭ **CameraKitSessionEvents**: [`TypedCustomEvent`](classes/TypedCustomEvent.md)<``"error"``, { `error`: [`LensExecutionError`](modules.md#lensexecutionerror) \| [`LensImagePickerError`](modules.md#lensimagepickererror) ; `lens`: [`Lens`](interfaces/Lens.md)  }\>
+
+Events emitted by [CameraKitSession.events](classes/CameraKitSession.md#events).
+
+The following events are emitted:
+  - `error`: An error has been encountered during lens rendering. May contain an error of type:
+    - [LensExecutionError](modules.md#lensexecutionerror) If an error of this type occurs, the rendering lens will be automatically removed
+from the associated CameraKitSession.
+    - [LensImagePickerError](modules.md#lensimagepickererror)
+
+___
+
+### Keyboard
+
+Ƭ **Keyboard**: `Object`
+
+Keyboard is an API enabling lenses to consume and render user-generated text.
+
+Applications that wish to use lenses that expect user-generated text will need to use this API to integrate text
+input into their user experience.
+
+There are two ways to do this:
+1. Add the provided DOM element (an HTMLTextAreaElement) to the page. When the user updates this element with text,
+that text will be sent to the currently active lens.
+2. Use the sendInputToLens method to send text strings to the currently active lens directly.
+
+Lenses will also signal to the application when text input is expected -- applications should add an event listener
+and ensure the user is able to input text when the `active` event is received.
+
+**`Example`**
+
+```ts
+cameraKitSession.keyboard.addEventListener('active', ({ detail }) => {
+  const { element, active } = detail
+  if (active) document.body.appendChild(element)
+  else element.remove()
+})
+```
+
+#### Type declaration
+
+| Name | Type |
+| :------ | :------ |
+| `addEventListener` | (`type`: ``"active"``, `callback`: `TypedEventListener`<[`KeyboardEvents`](modules.md#keyboardevents)\>, `options?`: `TypedEventListenerOptions`) => `void` |
+| `removeEventListener` | (`type`: ``"active"``, `callback`: `TypedEventListener`<[`KeyboardEvents`](modules.md#keyboardevents)\>) => `void` |
+| `getElement` | () => `HTMLTextAreaElement` |
+| `sendInputToLens` | (`text`: `string`) => `void` |
+| `dismiss` | () => `void` |
+
+## Metrics
+
+### LensMetricsEvents
+
+Ƭ **LensMetricsEvents**: [`TypedCustomEvent`](classes/TypedCustomEvent.md)<[`LensView`](modules.md#lensview)[``"name"``], [`LensView`](modules.md#lensview)\> \| [`TypedCustomEvent`](classes/TypedCustomEvent.md)<[`LensWait`](modules.md#lenswait)[``"name"``], [`LensWait`](modules.md#lenswait)\>
+
+Lens metrics events.
+
+These events are emitted by [CameraKit](classes/CameraKit.md) to report lens usage, performance, apply latency, etc.
+
+___
+
+### LensView
+
+Ƭ **LensView**: `MakeTaggedBusinessEvent`<``"lensView"``\>
+
+The LensView metric is emitted after a lens has been viewed (for longer than 100ms), when the lens is turned off.
+
+It contains information about rendering performance.
+
+Notes:
+  - If the page is hidden (e.g. user switches to a different tab, or application, or closes the tab, or closes the
+    browser, navigates to a new page, refreshes, etc.) this metric will be emitted at that time. This is to ensure
+    we don't lose the metric if the page is closed.
+  - If the page is hidden and then made visible again later (e.g. user switches to a different tab, then back), we
+    will begin measuring a new LensView. That is, we will not capture the time when the page is hidden even if the
+    lens is still rendering in the background.
+
+___
+
+### LensWait
+
+Ƭ **LensWait**: `MakeTaggedBusinessEvent`<``"lensWait"``\>
+
+The LensWait metric measures the time spent downloading the lens content and required assets. It gives an indication
+of the real UX impact of download latency. If lens content and assets are pre-loaded, the latency measured here
+should decrease – we measure between the request to apply a lens and when the lens is ready to render.
+
+## Other
+
+### UriHandlers
+
+Ƭ **UriHandlers**: [`UriHandler`](interfaces/UriHandler.md)[]
+
+Array of [UriHandler](interfaces/UriHandler.md) objects.
+
+___
+
+### Uri
+
+Ƭ **Uri**: \`${string}://${string}\`
+
+___
+
+### CameraKitSourceInfo
+
+Ƭ **CameraKitSourceInfo**: `Pick`<`UseMediaElementInput`, ``"media"`` \| ``"replayTrackingData"`` \| ``"useManualFrameProcessing"``\>
+
+___
+
+### LegalError
+
+Ƭ **LegalError**: `NamedError`<``"LegalError"``\>
+
+___
+
+### LensContentValidationError
+
+Ƭ **LensContentValidationError**: `NamedError`<``"LensContentValidationError"``\>
+
+___
+
+### LensError
+
+Ƭ **LensError**: `NamedError`<``"LensError"``\>
+
+___
+
+### CameraKitSourceError
+
+Ƭ **CameraKitSourceError**: `NamedError`<``"CameraKitSourceError"``\>
+
+___
+
+### LensImagePickerError
+
+Ƭ **LensImagePickerError**: `NamedError`<``"LensImagePickerError"``\>
+
+The error triggered when a lens prompts the user to select an image, but the image fails to be successfully delivered
+to the lens.
+
+___
+
+### CacheKeyNotFoundError
+
+Ƭ **CacheKeyNotFoundError**: `NamedError`<``"CacheKeyNotFoundError"``\>
+
+___
+
+### WebGLError
+
+Ƭ **WebGLError**: `NamedError`<``"WebGLError"``\>
+
+___
+
+### BenchmarkError
+
+Ƭ **BenchmarkError**: `NamedError`<``"BenchmarkError"``\>
+
+___
+
+### LensExecutionError
+
+Ƭ **LensExecutionError**: `NamedError`<``"LensExecutionError"``\>
+
+This error occurs if a Lens is unable to continue rendering.
+
+If this error occurs, Camera Kit automatically removes the Lens from the session.
+It's always a good idea to handle this error and update the user experience accordingly.
+For example, you could remove the faulty Lens from your Lens selection UI.
+
+```ts
+cameraKitSession.events.addEventListener('error', ({ detail }) => {
+  if (detail.error.name === 'LensExecutionError') {
+    console.log(`Lens ${detail.lens.name} encountered an error and was removed. Please pick a different lens.`)
+  }
+})
+```
+
+___
+
+### PersistentStoreError
+
+Ƭ **PersistentStoreError**: `NamedError`<``"PersistentStoreError"``\>
+
+Error thrown when LensCore asked to store lens data, but CameraKit failed storing that.
+
+___
+
+### LensAssetError
+
+Ƭ **LensAssetError**: `NamedError`<``"LensAssetError"``\>
+
+Error thrown when LensCore asked to provide an asset, but CameraKit failed providing that.
+
+___
+
+### CameraKitSessionEventListener
+
+Ƭ **CameraKitSessionEventListener**: `TypedEventListener`<[`CameraKitSessionEvents`](modules.md#camerakitsessionevents)\>
+
+Listener of [CameraKitSessionEvents](modules.md#camerakitsessionevents) events.
+
+___
+
+### KeyboardEvents
+
+Ƭ **KeyboardEvents**: [`TypedCustomEvent`](classes/TypedCustomEvent.md)<``"active"``, { `element`: `HTMLTextAreaElement` ; `active`: `boolean` ; `lens?`: [`Lens`](interfaces/Lens.md)  }\>
+
+Events emitted by [Keyboard](modules.md#keyboard).
+
+___
+
+### extensionRequestContext
+
+• `Const` **extensionRequestContext**: `ArrayBuffer`
+
+Extension request context.
+
+___
+
+### Injectable
+
+▸ **Injectable**<`Token`, `Service`\>(`token`, `fn`): `InjectableFunction`<`any`, [], `Token`, `Service`\>
+
+Create an Injectable function with no dependencies (i.e. arguments).
+
+Ex:
+```ts
+const createMyService = Factory(
+  'MyService',
+  () => { ... },
+)
+```
+
+#### Type parameters
+
+| Name | Type |
+| :------ | :------ |
+| `Token` | extends `string` |
+| `Service` | `Service` |
+
+#### Parameters
+
+| Name | Type | Description |
+| :------ | :------ | :------ |
+| `token` | `Token` | A unique string Token which will correspond to the created Service. |
+| `fn` | () => `Service` | A function with no arguments which returns the Service. |
+
+#### Returns
+
+`InjectableFunction`<`any`, [], `Token`, `Service`\>
+
+▸ **Injectable**<`Token`, `Tokens`, `Params`, `Service`\>(`token`, `dependencies`, `fn`): `Tokens`[``"length"``] extends `Params`[``"length"``] ? `InjectableFunction`<`ServicesFromTokenizedParams`<`Tokens`, `Params`\>, `Tokens`, `Token`, `Service`\> : `never`
+
+Create an Injectable function with dependencies (i.e. arguments).
+
+**Note:** the list of dependencies must be readonly – that is, a literal tuple marked `as const`. This tuple must
+contain only string literals or string consts.
+
+Ex:
+```ts
+const DependencyB = 'DependencyB'
+const createMyService = Factory(
+  'MyService',
+  ['DependencyA', DependencyB] as const,
+  (a: A, b: B) => { ... },
+)
+```
+
+#### Type parameters
+
+| Name | Type |
+| :------ | :------ |
+| `Token` | extends `string` |
+| `Tokens` | extends readonly `string`[] |
+| `Params` | extends readonly `any`[] |
+| `Service` | `Service` |
+
+#### Parameters
+
+| Name | Type | Description |
+| :------ | :------ | :------ |
+| `token` | `Token` | A unique string Token which will correspond to the created Service. |
+| `dependencies` | `Tokens` | A *readonly* list of Tokens corresponding to dependencies (i.e. arguments to the Factory), which will be resolved by the Container to which this Factory is provided. |
+| `fn` | (...`args`: `Tokens`[``"length"``] extends `Params`[``"length"``] ? `Params` : `void`[]) => `Service` | A function with arguments matching in type and length to the given list of dependencies. When called, it must return the Service. |
+
+#### Returns
+
+`Tokens`[``"length"``] extends `Params`[``"length"``] ? `InjectableFunction`<`ServicesFromTokenizedParams`<`Tokens`, `Params`\>, `Tokens`, `Token`, `Service`\> : `never`
+
+___
+
+### lensSourcesFactory
+
+▸ **lensSourcesFactory**(`...args`): [`LensSources`](classes/LensSources.md)
+
+#### Parameters
+
+| Name | Type |
+| :------ | :------ |
+| `...args` | [] |
+
+#### Returns
+
+[`LensSources`](classes/LensSources.md)
+
+___
+
+### uriHandlersFactory
+
+▸ **uriHandlersFactory**(`...args`): [`UriHandlers`](modules.md#urihandlers)
+
+An extension point for client URI handlers.
+
+#### Parameters
+
+| Name | Type |
+| :------ | :------ |
+| `...args` | [] |
+
+#### Returns
+
+[`UriHandlers`](modules.md#urihandlers)
+
+## Rendering
+
+### CameraKitDeviceInfo
+
+Ƭ **CameraKitDeviceInfo**: `Object`
+
+#### Type declaration
+
+| Name | Type |
+| :------ | :------ |
+| `cameraType` | ``"front"`` \| ``"back"`` |
+| `fpsLimit` | `number` |
+
+___
+
+### CameraKitSourceOptions
+
+Ƭ **CameraKitSourceOptions**<`T`\>: `Partial`<`T`\> & `Partial`<[`CameraKitDeviceInfo`](modules.md#camerakitdeviceinfo)\>
+
+#### Type parameters
+
+| Name | Type |
+| :------ | :------ |
+| `T` | {} |
+
+___
+
+### RenderTarget
+
+Ƭ **RenderTarget**: ``"live"`` \| ``"capture"``
+
+Enumerates the supported render targets.
+
+Lenses may render to different render targets, as designed by the lens creator. In CameraKit, it's possible to choose
+which render target to render, and the result for each target is available as a separate `<canvas>` element.
+
+___
+
+### CameraKitSessionEvents
+
+Ƭ **CameraKitSessionEvents**: [`TypedCustomEvent`](classes/TypedCustomEvent.md)<``"error"``, { `error`: [`LensExecutionError`](modules.md#lensexecutionerror) \| [`LensImagePickerError`](modules.md#lensimagepickererror) ; `lens`: [`Lens`](interfaces/Lens.md)  }\>
+
+Events emitted by [CameraKitSession.events](classes/CameraKitSession.md#events).
+
+The following events are emitted:
+  - `error`: An error has been encountered during lens rendering. May contain an error of type:
+    - [LensExecutionError](modules.md#lensexecutionerror) If an error of this type occurs, the rendering lens will be automatically removed
+from the associated CameraKitSession.
+    - [LensImagePickerError](modules.md#lensimagepickererror)
+
+___
+
+### createImageSource
+
+▸ **createImageSource**(`image`, `options?`): [`CameraKitSource`](classes/CameraKitSource.md)
+
+Create a [CameraKitSource](classes/CameraKitSource.md) from an
+[HTMLImageElement](https://developer.mozilla.org/en-US/docs/Web/API/HTMLImageElement).
+
+#### Parameters
+
+| Name | Type | Description |
+| :------ | :------ | :------ |
+| `image` | `HTMLImageElement` | Image element. |
+| `options` | [`CameraKitSourceOptions`](modules.md#camerakitsourceoptions)<{}\> |  |
+
+#### Returns
+
+[`CameraKitSource`](classes/CameraKitSource.md)
+
+___
+
+### createUserMediaSource
+
+▸ **createUserMediaSource**(`constraints?`, `options?`): `Promise`<[`CameraKitSource`](classes/CameraKitSource.md)\>
+
+Create a [CameraKitSource](classes/CameraKitSource.md) from a user's media device -- this calls
+[MediaDevices.getUserMedia](https://developer.mozilla.org/en-US/docs/Web/API/MediaDevices/getUserMedia) to get a
+MediaStream and then calls [createMediaStreamSource](modules.md#createmediastreamsource).
+
+#### Parameters
+
+| Name | Type | Description |
+| :------ | :------ | :------ |
+| `constraints` | `MediaStreamConstraints` | Specify contraints used to get a MediaStream from a media device. By default we simply request a video stream. |
+| `options` | [`CameraKitSourceOptions`](modules.md#camerakitsourceoptions)<[`MediaStreamSourceOptions`](interfaces/MediaStreamSourceOptions.md)\> |  |
+
+#### Returns
+
+`Promise`<[`CameraKitSource`](classes/CameraKitSource.md)\>
+
+A Promise, resolving to [CameraKitSource](classes/CameraKitSource.md)
+
+___
+
+### createMediaStreamSource
+
+▸ **createMediaStreamSource**(`stream`, `options?`): [`CameraKitSource`](classes/CameraKitSource.md)
+
+Create a [CameraKitSource](classes/CameraKitSource.md) from any
+[MediaStream](https://developer.mozilla.org/en-US/docs/Web/API/MediaStream).
+
+#### Parameters
+
+| Name | Type | Description |
+| :------ | :------ | :------ |
+| `stream` | `MediaStream` | Any MediaStream, such as obtained via `canvas.captureStream()` |
+| `options` | [`CameraKitSourceOptions`](modules.md#camerakitsourceoptions)<[`MediaStreamSourceOptions`](interfaces/MediaStreamSourceOptions.md)\> |  |
+
+#### Returns
+
+[`CameraKitSource`](classes/CameraKitSource.md)
+
+___
+
+### createVideoSource
+
+▸ **createVideoSource**(`video`, `options?`): [`CameraKitSource`](classes/CameraKitSource.md)
+
+Create a [CameraKitSource](classes/CameraKitSource.md) from an
+[HTMLVideoElement](https://developer.mozilla.org/en-US/docs/Web/API/HTMLVideoElement).
+
+#### Parameters
+
+| Name | Type | Description |
+| :------ | :------ | :------ |
+| `video` | `HTMLVideoElement` | CameraKit performs best when the source video is 720p – arbitrary resolutions are supported, but very high resolutions may not perform well. |
+| `options` | [`CameraKitSourceOptions`](modules.md#camerakitsourceoptions)<[`VideoSourceOptions`](interfaces/VideoSourceOptions.md)\> |  |
+
+#### Returns
+
+[`CameraKitSource`](classes/CameraKitSource.md)