@fluidframework/synthesize 2.0.0-dev.7.3.0.211848 → 2.0.0-dev.7.4.0.214930

package/dist/synthesize-alpha.d.ts

@@ -0,0 +1,110 @@
+/**
+ * Combined type for Optional and Required Async Fluid object Providers
+ */
+export declare type AsyncFluidObjectProvider<O, R = undefined> = AsyncOptionalFluidObjectProvider<O> & AsyncRequiredFluidObjectProvider<R>;
+
+/**
+ * This is a condensed version of Record that requires the object has all
+ * the FluidObject properties as its type, mapped to an object that implements
+ * the property or undefined.
+ */
+export declare type AsyncOptionalFluidObjectProvider<T> = T extends undefined ? Record<string, never> : {
+    [P in keyof T]?: Promise<T[P] | undefined>;
+};
+
+/**
+ * This is a condensed version of Record that requires the object has all
+ * the FluidObject properties as its type mapped to an object that implements
+ * the property.
+ */
+export declare type AsyncRequiredFluidObjectProvider<T> = T extends undefined ? Record<string, never> : {
+    [P in keyof T]: Promise<NonNullable<Exclude<T[P], undefined | null>>>;
+};
+
+/**
+ * DependencyContainer is similar to a IoC Container. It takes providers and will
+ * synthesize an object based on them when requested.
+ */
+export declare class DependencyContainer<TMap> implements IFluidDependencySynthesizer {
+    private readonly providers;
+    private readonly parents;
+    get IFluidDependencySynthesizer(): this;
+    constructor(...parents: (IFluidDependencySynthesizer | undefined)[]);
+    /**
+     * Add a new provider
+     * @param type - Name of the Type T being provided
+     * @param provider - A provider that will resolve the T correctly when asked
+     * @throws - If passing a type that's already registered
+     */
+    register<T extends keyof TMap = keyof TMap>(type: T, provider: FluidObjectProvider<Pick<TMap, T>>): void;
+    /**
+     * Remove a provider
+     * @param type - Name of the provider to remove
+     */
+    unregister(type: keyof TMap): void;
+    /**
+     * {@inheritDoc (IFluidDependencySynthesizer:interface).synthesize}
+     */
+    synthesize<O, R = undefined | Record<string, never>>(optionalTypes: FluidObjectSymbolProvider<O>, requiredTypes: Required<FluidObjectSymbolProvider<R>>): AsyncFluidObjectProvider<O, R>;
+    /**
+     * {@inheritDoc (IFluidDependencySynthesizer:interface).has}
+     * @param excludeParents - If true, exclude checking parent registries
+     */
+    has(type: string, excludeParents?: boolean): boolean;
+    /**
+     * @deprecated Needed for backwards compatability.
+     */
+    private getProvider;
+    private generateRequired;
+    private generateOptional;
+    private resolveProvider;
+}
+
+/**
+ * Multiple ways to provide a Fluid object.
+ */
+export declare type FluidObjectProvider<T> = NonNullable<T> | Promise<NonNullable<T>> | ((dependencyContainer: IFluidDependencySynthesizer) => NonNullable<T>) | ((dependencyContainer: IFluidDependencySynthesizer) => Promise<NonNullable<T>>);
+
+/**
+ * This is a condensed version of Record that requires the object has all
+ * the FluidObject properties as its type mapped to a string representation
+ * of that property.
+ *
+ * @example
+ *
+ * ```typescript
+ * { IFoo: "IFoo" }
+ * ```
+ */
+export declare type FluidObjectSymbolProvider<T> = {
+    [P in keyof T]?: P;
+};
+
+export declare const IFluidDependencySynthesizer: keyof IProvideFluidDependencySynthesizer;
+
+/**
+ * IFluidDependencySynthesizer can generate FluidObjects based on the IProvideFluidObject pattern.
+ * It allow for registering providers and uses synthesize to generate a new object with the optional
+ * and required types.
+ */
+export declare interface IFluidDependencySynthesizer extends IProvideFluidDependencySynthesizer {
+    /**
+     * synthesize takes optional and required types and returns an object that will fulfill the
+     * defined types based off objects that has been previously registered.
+     *
+     * @param optionalTypes - optional types to be in the Scope object
+     * @param requiredTypes - required types that need to be in the Scope object
+     */
+    synthesize<O, R = undefined | Record<string, never>>(optionalTypes: FluidObjectSymbolProvider<O>, requiredTypes: Required<FluidObjectSymbolProvider<R>>): AsyncFluidObjectProvider<O, R>;
+    /**
+     * Check if a given type is registered
+     * @param type - Type to check
+     */
+    has(type: string): boolean;
+}
+
+export declare interface IProvideFluidDependencySynthesizer {
+    IFluidDependencySynthesizer: IFluidDependencySynthesizer;
+}
+
+export { }

package/dist/synthesize-beta.d.ts

@@ -0,0 +1,110 @@
+/**
+ * Combined type for Optional and Required Async Fluid object Providers
+ */
+export declare type AsyncFluidObjectProvider<O, R = undefined> = AsyncOptionalFluidObjectProvider<O> & AsyncRequiredFluidObjectProvider<R>;
+
+/**
+ * This is a condensed version of Record that requires the object has all
+ * the FluidObject properties as its type, mapped to an object that implements
+ * the property or undefined.
+ */
+export declare type AsyncOptionalFluidObjectProvider<T> = T extends undefined ? Record<string, never> : {
+    [P in keyof T]?: Promise<T[P] | undefined>;
+};
+
+/**
+ * This is a condensed version of Record that requires the object has all
+ * the FluidObject properties as its type mapped to an object that implements
+ * the property.
+ */
+export declare type AsyncRequiredFluidObjectProvider<T> = T extends undefined ? Record<string, never> : {
+    [P in keyof T]: Promise<NonNullable<Exclude<T[P], undefined | null>>>;
+};
+
+/**
+ * DependencyContainer is similar to a IoC Container. It takes providers and will
+ * synthesize an object based on them when requested.
+ */
+export declare class DependencyContainer<TMap> implements IFluidDependencySynthesizer {
+    private readonly providers;
+    private readonly parents;
+    get IFluidDependencySynthesizer(): this;
+    constructor(...parents: (IFluidDependencySynthesizer | undefined)[]);
+    /**
+     * Add a new provider
+     * @param type - Name of the Type T being provided
+     * @param provider - A provider that will resolve the T correctly when asked
+     * @throws - If passing a type that's already registered
+     */
+    register<T extends keyof TMap = keyof TMap>(type: T, provider: FluidObjectProvider<Pick<TMap, T>>): void;
+    /**
+     * Remove a provider
+     * @param type - Name of the provider to remove
+     */
+    unregister(type: keyof TMap): void;
+    /**
+     * {@inheritDoc (IFluidDependencySynthesizer:interface).synthesize}
+     */
+    synthesize<O, R = undefined | Record<string, never>>(optionalTypes: FluidObjectSymbolProvider<O>, requiredTypes: Required<FluidObjectSymbolProvider<R>>): AsyncFluidObjectProvider<O, R>;
+    /**
+     * {@inheritDoc (IFluidDependencySynthesizer:interface).has}
+     * @param excludeParents - If true, exclude checking parent registries
+     */
+    has(type: string, excludeParents?: boolean): boolean;
+    /**
+     * @deprecated Needed for backwards compatability.
+     */
+    private getProvider;
+    private generateRequired;
+    private generateOptional;
+    private resolveProvider;
+}
+
+/**
+ * Multiple ways to provide a Fluid object.
+ */
+export declare type FluidObjectProvider<T> = NonNullable<T> | Promise<NonNullable<T>> | ((dependencyContainer: IFluidDependencySynthesizer) => NonNullable<T>) | ((dependencyContainer: IFluidDependencySynthesizer) => Promise<NonNullable<T>>);
+
+/**
+ * This is a condensed version of Record that requires the object has all
+ * the FluidObject properties as its type mapped to a string representation
+ * of that property.
+ *
+ * @example
+ *
+ * ```typescript
+ * { IFoo: "IFoo" }
+ * ```
+ */
+export declare type FluidObjectSymbolProvider<T> = {
+    [P in keyof T]?: P;
+};
+
+export declare const IFluidDependencySynthesizer: keyof IProvideFluidDependencySynthesizer;
+
+/**
+ * IFluidDependencySynthesizer can generate FluidObjects based on the IProvideFluidObject pattern.
+ * It allow for registering providers and uses synthesize to generate a new object with the optional
+ * and required types.
+ */
+export declare interface IFluidDependencySynthesizer extends IProvideFluidDependencySynthesizer {
+    /**
+     * synthesize takes optional and required types and returns an object that will fulfill the
+     * defined types based off objects that has been previously registered.
+     *
+     * @param optionalTypes - optional types to be in the Scope object
+     * @param requiredTypes - required types that need to be in the Scope object
+     */
+    synthesize<O, R = undefined | Record<string, never>>(optionalTypes: FluidObjectSymbolProvider<O>, requiredTypes: Required<FluidObjectSymbolProvider<R>>): AsyncFluidObjectProvider<O, R>;
+    /**
+     * Check if a given type is registered
+     * @param type - Type to check
+     */
+    has(type: string): boolean;
+}
+
+export declare interface IProvideFluidDependencySynthesizer {
+    IFluidDependencySynthesizer: IFluidDependencySynthesizer;
+}
+
+export { }

package/dist/synthesize-public.d.ts

@@ -0,0 +1,110 @@
+/**
+ * Combined type for Optional and Required Async Fluid object Providers
+ */
+export declare type AsyncFluidObjectProvider<O, R = undefined> = AsyncOptionalFluidObjectProvider<O> & AsyncRequiredFluidObjectProvider<R>;
+
+/**
+ * This is a condensed version of Record that requires the object has all
+ * the FluidObject properties as its type, mapped to an object that implements
+ * the property or undefined.
+ */
+export declare type AsyncOptionalFluidObjectProvider<T> = T extends undefined ? Record<string, never> : {
+    [P in keyof T]?: Promise<T[P] | undefined>;
+};
+
+/**
+ * This is a condensed version of Record that requires the object has all
+ * the FluidObject properties as its type mapped to an object that implements
+ * the property.
+ */
+export declare type AsyncRequiredFluidObjectProvider<T> = T extends undefined ? Record<string, never> : {
+    [P in keyof T]: Promise<NonNullable<Exclude<T[P], undefined | null>>>;
+};
+
+/**
+ * DependencyContainer is similar to a IoC Container. It takes providers and will
+ * synthesize an object based on them when requested.
+ */
+export declare class DependencyContainer<TMap> implements IFluidDependencySynthesizer {
+    private readonly providers;
+    private readonly parents;
+    get IFluidDependencySynthesizer(): this;
+    constructor(...parents: (IFluidDependencySynthesizer | undefined)[]);
+    /**
+     * Add a new provider
+     * @param type - Name of the Type T being provided
+     * @param provider - A provider that will resolve the T correctly when asked
+     * @throws - If passing a type that's already registered
+     */
+    register<T extends keyof TMap = keyof TMap>(type: T, provider: FluidObjectProvider<Pick<TMap, T>>): void;
+    /**
+     * Remove a provider
+     * @param type - Name of the provider to remove
+     */
+    unregister(type: keyof TMap): void;
+    /**
+     * {@inheritDoc (IFluidDependencySynthesizer:interface).synthesize}
+     */
+    synthesize<O, R = undefined | Record<string, never>>(optionalTypes: FluidObjectSymbolProvider<O>, requiredTypes: Required<FluidObjectSymbolProvider<R>>): AsyncFluidObjectProvider<O, R>;
+    /**
+     * {@inheritDoc (IFluidDependencySynthesizer:interface).has}
+     * @param excludeParents - If true, exclude checking parent registries
+     */
+    has(type: string, excludeParents?: boolean): boolean;
+    /**
+     * @deprecated Needed for backwards compatability.
+     */
+    private getProvider;
+    private generateRequired;
+    private generateOptional;
+    private resolveProvider;
+}
+
+/**
+ * Multiple ways to provide a Fluid object.
+ */
+export declare type FluidObjectProvider<T> = NonNullable<T> | Promise<NonNullable<T>> | ((dependencyContainer: IFluidDependencySynthesizer) => NonNullable<T>) | ((dependencyContainer: IFluidDependencySynthesizer) => Promise<NonNullable<T>>);
+
+/**
+ * This is a condensed version of Record that requires the object has all
+ * the FluidObject properties as its type mapped to a string representation
+ * of that property.
+ *
+ * @example
+ *
+ * ```typescript
+ * { IFoo: "IFoo" }
+ * ```
+ */
+export declare type FluidObjectSymbolProvider<T> = {
+    [P in keyof T]?: P;
+};
+
+export declare const IFluidDependencySynthesizer: keyof IProvideFluidDependencySynthesizer;
+
+/**
+ * IFluidDependencySynthesizer can generate FluidObjects based on the IProvideFluidObject pattern.
+ * It allow for registering providers and uses synthesize to generate a new object with the optional
+ * and required types.
+ */
+export declare interface IFluidDependencySynthesizer extends IProvideFluidDependencySynthesizer {
+    /**
+     * synthesize takes optional and required types and returns an object that will fulfill the
+     * defined types based off objects that has been previously registered.
+     *
+     * @param optionalTypes - optional types to be in the Scope object
+     * @param requiredTypes - required types that need to be in the Scope object
+     */
+    synthesize<O, R = undefined | Record<string, never>>(optionalTypes: FluidObjectSymbolProvider<O>, requiredTypes: Required<FluidObjectSymbolProvider<R>>): AsyncFluidObjectProvider<O, R>;
+    /**
+     * Check if a given type is registered
+     * @param type - Type to check
+     */
+    has(type: string): boolean;
+}
+
+export declare interface IProvideFluidDependencySynthesizer {
+    IFluidDependencySynthesizer: IFluidDependencySynthesizer;
+}
+
+export { }

package/dist/synthesize-untrimmed.d.ts

@@ -0,0 +1,110 @@
+/**
+ * Combined type for Optional and Required Async Fluid object Providers
+ */
+export declare type AsyncFluidObjectProvider<O, R = undefined> = AsyncOptionalFluidObjectProvider<O> & AsyncRequiredFluidObjectProvider<R>;
+
+/**
+ * This is a condensed version of Record that requires the object has all
+ * the FluidObject properties as its type, mapped to an object that implements
+ * the property or undefined.
+ */
+export declare type AsyncOptionalFluidObjectProvider<T> = T extends undefined ? Record<string, never> : {
+    [P in keyof T]?: Promise<T[P] | undefined>;
+};
+
+/**
+ * This is a condensed version of Record that requires the object has all
+ * the FluidObject properties as its type mapped to an object that implements
+ * the property.
+ */
+export declare type AsyncRequiredFluidObjectProvider<T> = T extends undefined ? Record<string, never> : {
+    [P in keyof T]: Promise<NonNullable<Exclude<T[P], undefined | null>>>;
+};
+
+/**
+ * DependencyContainer is similar to a IoC Container. It takes providers and will
+ * synthesize an object based on them when requested.
+ */
+export declare class DependencyContainer<TMap> implements IFluidDependencySynthesizer {
+    private readonly providers;
+    private readonly parents;
+    get IFluidDependencySynthesizer(): this;
+    constructor(...parents: (IFluidDependencySynthesizer | undefined)[]);
+    /**
+     * Add a new provider
+     * @param type - Name of the Type T being provided
+     * @param provider - A provider that will resolve the T correctly when asked
+     * @throws - If passing a type that's already registered
+     */
+    register<T extends keyof TMap = keyof TMap>(type: T, provider: FluidObjectProvider<Pick<TMap, T>>): void;
+    /**
+     * Remove a provider
+     * @param type - Name of the provider to remove
+     */
+    unregister(type: keyof TMap): void;
+    /**
+     * {@inheritDoc (IFluidDependencySynthesizer:interface).synthesize}
+     */
+    synthesize<O, R = undefined | Record<string, never>>(optionalTypes: FluidObjectSymbolProvider<O>, requiredTypes: Required<FluidObjectSymbolProvider<R>>): AsyncFluidObjectProvider<O, R>;
+    /**
+     * {@inheritDoc (IFluidDependencySynthesizer:interface).has}
+     * @param excludeParents - If true, exclude checking parent registries
+     */
+    has(type: string, excludeParents?: boolean): boolean;
+    /**
+     * @deprecated Needed for backwards compatability.
+     */
+    private getProvider;
+    private generateRequired;
+    private generateOptional;
+    private resolveProvider;
+}
+
+/**
+ * Multiple ways to provide a Fluid object.
+ */
+export declare type FluidObjectProvider<T> = NonNullable<T> | Promise<NonNullable<T>> | ((dependencyContainer: IFluidDependencySynthesizer) => NonNullable<T>) | ((dependencyContainer: IFluidDependencySynthesizer) => Promise<NonNullable<T>>);
+
+/**
+ * This is a condensed version of Record that requires the object has all
+ * the FluidObject properties as its type mapped to a string representation
+ * of that property.
+ *
+ * @example
+ *
+ * ```typescript
+ * { IFoo: "IFoo" }
+ * ```
+ */
+export declare type FluidObjectSymbolProvider<T> = {
+    [P in keyof T]?: P;
+};
+
+export declare const IFluidDependencySynthesizer: keyof IProvideFluidDependencySynthesizer;
+
+/**
+ * IFluidDependencySynthesizer can generate FluidObjects based on the IProvideFluidObject pattern.
+ * It allow for registering providers and uses synthesize to generate a new object with the optional
+ * and required types.
+ */
+export declare interface IFluidDependencySynthesizer extends IProvideFluidDependencySynthesizer {
+    /**
+     * synthesize takes optional and required types and returns an object that will fulfill the
+     * defined types based off objects that has been previously registered.
+     *
+     * @param optionalTypes - optional types to be in the Scope object
+     * @param requiredTypes - required types that need to be in the Scope object
+     */
+    synthesize<O, R = undefined | Record<string, never>>(optionalTypes: FluidObjectSymbolProvider<O>, requiredTypes: Required<FluidObjectSymbolProvider<R>>): AsyncFluidObjectProvider<O, R>;
+    /**
+     * Check if a given type is registered
+     * @param type - Type to check
+     */
+    has(type: string): boolean;
+}
+
+export declare interface IProvideFluidDependencySynthesizer {
+    IFluidDependencySynthesizer: IFluidDependencySynthesizer;
+}
+
+export { }

package/lib/synthesize-alpha.d.ts

@@ -0,0 +1,110 @@
+/**
+ * Combined type for Optional and Required Async Fluid object Providers
+ */
+export declare type AsyncFluidObjectProvider<O, R = undefined> = AsyncOptionalFluidObjectProvider<O> & AsyncRequiredFluidObjectProvider<R>;
+
+/**
+ * This is a condensed version of Record that requires the object has all
+ * the FluidObject properties as its type, mapped to an object that implements
+ * the property or undefined.
+ */
+export declare type AsyncOptionalFluidObjectProvider<T> = T extends undefined ? Record<string, never> : {
+    [P in keyof T]?: Promise<T[P] | undefined>;
+};
+
+/**
+ * This is a condensed version of Record that requires the object has all
+ * the FluidObject properties as its type mapped to an object that implements
+ * the property.
+ */
+export declare type AsyncRequiredFluidObjectProvider<T> = T extends undefined ? Record<string, never> : {
+    [P in keyof T]: Promise<NonNullable<Exclude<T[P], undefined | null>>>;
+};
+
+/**
+ * DependencyContainer is similar to a IoC Container. It takes providers and will
+ * synthesize an object based on them when requested.
+ */
+export declare class DependencyContainer<TMap> implements IFluidDependencySynthesizer {
+    private readonly providers;
+    private readonly parents;
+    get IFluidDependencySynthesizer(): this;
+    constructor(...parents: (IFluidDependencySynthesizer | undefined)[]);
+    /**
+     * Add a new provider
+     * @param type - Name of the Type T being provided
+     * @param provider - A provider that will resolve the T correctly when asked
+     * @throws - If passing a type that's already registered
+     */
+    register<T extends keyof TMap = keyof TMap>(type: T, provider: FluidObjectProvider<Pick<TMap, T>>): void;
+    /**
+     * Remove a provider
+     * @param type - Name of the provider to remove
+     */
+    unregister(type: keyof TMap): void;
+    /**
+     * {@inheritDoc (IFluidDependencySynthesizer:interface).synthesize}
+     */
+    synthesize<O, R = undefined | Record<string, never>>(optionalTypes: FluidObjectSymbolProvider<O>, requiredTypes: Required<FluidObjectSymbolProvider<R>>): AsyncFluidObjectProvider<O, R>;
+    /**
+     * {@inheritDoc (IFluidDependencySynthesizer:interface).has}
+     * @param excludeParents - If true, exclude checking parent registries
+     */
+    has(type: string, excludeParents?: boolean): boolean;
+    /**
+     * @deprecated Needed for backwards compatability.
+     */
+    private getProvider;
+    private generateRequired;
+    private generateOptional;
+    private resolveProvider;
+}
+
+/**
+ * Multiple ways to provide a Fluid object.
+ */
+export declare type FluidObjectProvider<T> = NonNullable<T> | Promise<NonNullable<T>> | ((dependencyContainer: IFluidDependencySynthesizer) => NonNullable<T>) | ((dependencyContainer: IFluidDependencySynthesizer) => Promise<NonNullable<T>>);
+
+/**
+ * This is a condensed version of Record that requires the object has all
+ * the FluidObject properties as its type mapped to a string representation
+ * of that property.
+ *
+ * @example
+ *
+ * ```typescript
+ * { IFoo: "IFoo" }
+ * ```
+ */
+export declare type FluidObjectSymbolProvider<T> = {
+    [P in keyof T]?: P;
+};
+
+export declare const IFluidDependencySynthesizer: keyof IProvideFluidDependencySynthesizer;
+
+/**
+ * IFluidDependencySynthesizer can generate FluidObjects based on the IProvideFluidObject pattern.
+ * It allow for registering providers and uses synthesize to generate a new object with the optional
+ * and required types.
+ */
+export declare interface IFluidDependencySynthesizer extends IProvideFluidDependencySynthesizer {
+    /**
+     * synthesize takes optional and required types and returns an object that will fulfill the
+     * defined types based off objects that has been previously registered.
+     *
+     * @param optionalTypes - optional types to be in the Scope object
+     * @param requiredTypes - required types that need to be in the Scope object
+     */
+    synthesize<O, R = undefined | Record<string, never>>(optionalTypes: FluidObjectSymbolProvider<O>, requiredTypes: Required<FluidObjectSymbolProvider<R>>): AsyncFluidObjectProvider<O, R>;
+    /**
+     * Check if a given type is registered
+     * @param type - Type to check
+     */
+    has(type: string): boolean;
+}
+
+export declare interface IProvideFluidDependencySynthesizer {
+    IFluidDependencySynthesizer: IFluidDependencySynthesizer;
+}
+
+export { }

package/lib/synthesize-beta.d.ts

@@ -0,0 +1,110 @@
+/**
+ * Combined type for Optional and Required Async Fluid object Providers
+ */
+export declare type AsyncFluidObjectProvider<O, R = undefined> = AsyncOptionalFluidObjectProvider<O> & AsyncRequiredFluidObjectProvider<R>;
+
+/**
+ * This is a condensed version of Record that requires the object has all
+ * the FluidObject properties as its type, mapped to an object that implements
+ * the property or undefined.
+ */
+export declare type AsyncOptionalFluidObjectProvider<T> = T extends undefined ? Record<string, never> : {
+    [P in keyof T]?: Promise<T[P] | undefined>;
+};
+
+/**
+ * This is a condensed version of Record that requires the object has all
+ * the FluidObject properties as its type mapped to an object that implements
+ * the property.
+ */
+export declare type AsyncRequiredFluidObjectProvider<T> = T extends undefined ? Record<string, never> : {
+    [P in keyof T]: Promise<NonNullable<Exclude<T[P], undefined | null>>>;
+};
+
+/**
+ * DependencyContainer is similar to a IoC Container. It takes providers and will
+ * synthesize an object based on them when requested.
+ */
+export declare class DependencyContainer<TMap> implements IFluidDependencySynthesizer {
+    private readonly providers;
+    private readonly parents;
+    get IFluidDependencySynthesizer(): this;
+    constructor(...parents: (IFluidDependencySynthesizer | undefined)[]);
+    /**
+     * Add a new provider
+     * @param type - Name of the Type T being provided
+     * @param provider - A provider that will resolve the T correctly when asked
+     * @throws - If passing a type that's already registered
+     */
+    register<T extends keyof TMap = keyof TMap>(type: T, provider: FluidObjectProvider<Pick<TMap, T>>): void;
+    /**
+     * Remove a provider
+     * @param type - Name of the provider to remove
+     */
+    unregister(type: keyof TMap): void;
+    /**
+     * {@inheritDoc (IFluidDependencySynthesizer:interface).synthesize}
+     */
+    synthesize<O, R = undefined | Record<string, never>>(optionalTypes: FluidObjectSymbolProvider<O>, requiredTypes: Required<FluidObjectSymbolProvider<R>>): AsyncFluidObjectProvider<O, R>;
+    /**
+     * {@inheritDoc (IFluidDependencySynthesizer:interface).has}
+     * @param excludeParents - If true, exclude checking parent registries
+     */
+    has(type: string, excludeParents?: boolean): boolean;
+    /**
+     * @deprecated Needed for backwards compatability.
+     */
+    private getProvider;
+    private generateRequired;
+    private generateOptional;
+    private resolveProvider;
+}
+
+/**
+ * Multiple ways to provide a Fluid object.
+ */
+export declare type FluidObjectProvider<T> = NonNullable<T> | Promise<NonNullable<T>> | ((dependencyContainer: IFluidDependencySynthesizer) => NonNullable<T>) | ((dependencyContainer: IFluidDependencySynthesizer) => Promise<NonNullable<T>>);
+
+/**
+ * This is a condensed version of Record that requires the object has all
+ * the FluidObject properties as its type mapped to a string representation
+ * of that property.
+ *
+ * @example
+ *
+ * ```typescript
+ * { IFoo: "IFoo" }
+ * ```
+ */
+export declare type FluidObjectSymbolProvider<T> = {
+    [P in keyof T]?: P;
+};
+
+export declare const IFluidDependencySynthesizer: keyof IProvideFluidDependencySynthesizer;
+
+/**
+ * IFluidDependencySynthesizer can generate FluidObjects based on the IProvideFluidObject pattern.
+ * It allow for registering providers and uses synthesize to generate a new object with the optional
+ * and required types.
+ */
+export declare interface IFluidDependencySynthesizer extends IProvideFluidDependencySynthesizer {
+    /**
+     * synthesize takes optional and required types and returns an object that will fulfill the
+     * defined types based off objects that has been previously registered.
+     *
+     * @param optionalTypes - optional types to be in the Scope object
+     * @param requiredTypes - required types that need to be in the Scope object
+     */
+    synthesize<O, R = undefined | Record<string, never>>(optionalTypes: FluidObjectSymbolProvider<O>, requiredTypes: Required<FluidObjectSymbolProvider<R>>): AsyncFluidObjectProvider<O, R>;
+    /**
+     * Check if a given type is registered
+     * @param type - Type to check
+     */
+    has(type: string): boolean;
+}
+
+export declare interface IProvideFluidDependencySynthesizer {
+    IFluidDependencySynthesizer: IFluidDependencySynthesizer;
+}
+
+export { }

package/lib/synthesize-public.d.ts

@@ -0,0 +1,110 @@
+/**
+ * Combined type for Optional and Required Async Fluid object Providers
+ */
+export declare type AsyncFluidObjectProvider<O, R = undefined> = AsyncOptionalFluidObjectProvider<O> & AsyncRequiredFluidObjectProvider<R>;
+
+/**
+ * This is a condensed version of Record that requires the object has all
+ * the FluidObject properties as its type, mapped to an object that implements
+ * the property or undefined.
+ */
+export declare type AsyncOptionalFluidObjectProvider<T> = T extends undefined ? Record<string, never> : {
+    [P in keyof T]?: Promise<T[P] | undefined>;
+};
+
+/**
+ * This is a condensed version of Record that requires the object has all
+ * the FluidObject properties as its type mapped to an object that implements
+ * the property.
+ */
+export declare type AsyncRequiredFluidObjectProvider<T> = T extends undefined ? Record<string, never> : {
+    [P in keyof T]: Promise<NonNullable<Exclude<T[P], undefined | null>>>;
+};
+
+/**
+ * DependencyContainer is similar to a IoC Container. It takes providers and will
+ * synthesize an object based on them when requested.
+ */
+export declare class DependencyContainer<TMap> implements IFluidDependencySynthesizer {
+    private readonly providers;
+    private readonly parents;
+    get IFluidDependencySynthesizer(): this;
+    constructor(...parents: (IFluidDependencySynthesizer | undefined)[]);
+    /**
+     * Add a new provider
+     * @param type - Name of the Type T being provided
+     * @param provider - A provider that will resolve the T correctly when asked
+     * @throws - If passing a type that's already registered
+     */
+    register<T extends keyof TMap = keyof TMap>(type: T, provider: FluidObjectProvider<Pick<TMap, T>>): void;
+    /**
+     * Remove a provider
+     * @param type - Name of the provider to remove
+     */
+    unregister(type: keyof TMap): void;
+    /**
+     * {@inheritDoc (IFluidDependencySynthesizer:interface).synthesize}
+     */
+    synthesize<O, R = undefined | Record<string, never>>(optionalTypes: FluidObjectSymbolProvider<O>, requiredTypes: Required<FluidObjectSymbolProvider<R>>): AsyncFluidObjectProvider<O, R>;
+    /**
+     * {@inheritDoc (IFluidDependencySynthesizer:interface).has}
+     * @param excludeParents - If true, exclude checking parent registries
+     */
+    has(type: string, excludeParents?: boolean): boolean;
+    /**
+     * @deprecated Needed for backwards compatability.
+     */
+    private getProvider;
+    private generateRequired;
+    private generateOptional;
+    private resolveProvider;
+}
+
+/**
+ * Multiple ways to provide a Fluid object.
+ */
+export declare type FluidObjectProvider<T> = NonNullable<T> | Promise<NonNullable<T>> | ((dependencyContainer: IFluidDependencySynthesizer) => NonNullable<T>) | ((dependencyContainer: IFluidDependencySynthesizer) => Promise<NonNullable<T>>);
+
+/**
+ * This is a condensed version of Record that requires the object has all
+ * the FluidObject properties as its type mapped to a string representation
+ * of that property.
+ *
+ * @example
+ *
+ * ```typescript
+ * { IFoo: "IFoo" }
+ * ```
+ */
+export declare type FluidObjectSymbolProvider<T> = {
+    [P in keyof T]?: P;
+};
+
+export declare const IFluidDependencySynthesizer: keyof IProvideFluidDependencySynthesizer;
+
+/**
+ * IFluidDependencySynthesizer can generate FluidObjects based on the IProvideFluidObject pattern.
+ * It allow for registering providers and uses synthesize to generate a new object with the optional
+ * and required types.
+ */
+export declare interface IFluidDependencySynthesizer extends IProvideFluidDependencySynthesizer {
+    /**
+     * synthesize takes optional and required types and returns an object that will fulfill the
+     * defined types based off objects that has been previously registered.
+     *
+     * @param optionalTypes - optional types to be in the Scope object
+     * @param requiredTypes - required types that need to be in the Scope object
+     */
+    synthesize<O, R = undefined | Record<string, never>>(optionalTypes: FluidObjectSymbolProvider<O>, requiredTypes: Required<FluidObjectSymbolProvider<R>>): AsyncFluidObjectProvider<O, R>;
+    /**
+     * Check if a given type is registered
+     * @param type - Type to check
+     */
+    has(type: string): boolean;
+}
+
+export declare interface IProvideFluidDependencySynthesizer {
+    IFluidDependencySynthesizer: IFluidDependencySynthesizer;
+}
+
+export { }

package/lib/synthesize-untrimmed.d.ts

@@ -0,0 +1,110 @@
+/**
+ * Combined type for Optional and Required Async Fluid object Providers
+ */
+export declare type AsyncFluidObjectProvider<O, R = undefined> = AsyncOptionalFluidObjectProvider<O> & AsyncRequiredFluidObjectProvider<R>;
+
+/**
+ * This is a condensed version of Record that requires the object has all
+ * the FluidObject properties as its type, mapped to an object that implements
+ * the property or undefined.
+ */
+export declare type AsyncOptionalFluidObjectProvider<T> = T extends undefined ? Record<string, never> : {
+    [P in keyof T]?: Promise<T[P] | undefined>;
+};
+
+/**
+ * This is a condensed version of Record that requires the object has all
+ * the FluidObject properties as its type mapped to an object that implements
+ * the property.
+ */
+export declare type AsyncRequiredFluidObjectProvider<T> = T extends undefined ? Record<string, never> : {
+    [P in keyof T]: Promise<NonNullable<Exclude<T[P], undefined | null>>>;
+};
+
+/**
+ * DependencyContainer is similar to a IoC Container. It takes providers and will
+ * synthesize an object based on them when requested.
+ */
+export declare class DependencyContainer<TMap> implements IFluidDependencySynthesizer {
+    private readonly providers;
+    private readonly parents;
+    get IFluidDependencySynthesizer(): this;
+    constructor(...parents: (IFluidDependencySynthesizer | undefined)[]);
+    /**
+     * Add a new provider
+     * @param type - Name of the Type T being provided
+     * @param provider - A provider that will resolve the T correctly when asked
+     * @throws - If passing a type that's already registered
+     */
+    register<T extends keyof TMap = keyof TMap>(type: T, provider: FluidObjectProvider<Pick<TMap, T>>): void;
+    /**
+     * Remove a provider
+     * @param type - Name of the provider to remove
+     */
+    unregister(type: keyof TMap): void;
+    /**
+     * {@inheritDoc (IFluidDependencySynthesizer:interface).synthesize}
+     */
+    synthesize<O, R = undefined | Record<string, never>>(optionalTypes: FluidObjectSymbolProvider<O>, requiredTypes: Required<FluidObjectSymbolProvider<R>>): AsyncFluidObjectProvider<O, R>;
+    /**
+     * {@inheritDoc (IFluidDependencySynthesizer:interface).has}
+     * @param excludeParents - If true, exclude checking parent registries
+     */
+    has(type: string, excludeParents?: boolean): boolean;
+    /**
+     * @deprecated Needed for backwards compatability.
+     */
+    private getProvider;
+    private generateRequired;
+    private generateOptional;
+    private resolveProvider;
+}
+
+/**
+ * Multiple ways to provide a Fluid object.
+ */
+export declare type FluidObjectProvider<T> = NonNullable<T> | Promise<NonNullable<T>> | ((dependencyContainer: IFluidDependencySynthesizer) => NonNullable<T>) | ((dependencyContainer: IFluidDependencySynthesizer) => Promise<NonNullable<T>>);
+
+/**
+ * This is a condensed version of Record that requires the object has all
+ * the FluidObject properties as its type mapped to a string representation
+ * of that property.
+ *
+ * @example
+ *
+ * ```typescript
+ * { IFoo: "IFoo" }
+ * ```
+ */
+export declare type FluidObjectSymbolProvider<T> = {
+    [P in keyof T]?: P;
+};
+
+export declare const IFluidDependencySynthesizer: keyof IProvideFluidDependencySynthesizer;
+
+/**
+ * IFluidDependencySynthesizer can generate FluidObjects based on the IProvideFluidObject pattern.
+ * It allow for registering providers and uses synthesize to generate a new object with the optional
+ * and required types.
+ */
+export declare interface IFluidDependencySynthesizer extends IProvideFluidDependencySynthesizer {
+    /**
+     * synthesize takes optional and required types and returns an object that will fulfill the
+     * defined types based off objects that has been previously registered.
+     *
+     * @param optionalTypes - optional types to be in the Scope object
+     * @param requiredTypes - required types that need to be in the Scope object
+     */
+    synthesize<O, R = undefined | Record<string, never>>(optionalTypes: FluidObjectSymbolProvider<O>, requiredTypes: Required<FluidObjectSymbolProvider<R>>): AsyncFluidObjectProvider<O, R>;
+    /**
+     * Check if a given type is registered
+     * @param type - Type to check
+     */
+    has(type: string): boolean;
+}
+
+export declare interface IProvideFluidDependencySynthesizer {
+    IFluidDependencySynthesizer: IFluidDependencySynthesizer;
+}
+
+export { }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fluidframework/synthesize",
-  "version": "2.0.0-dev.7.3.0.211848",
+  "version": "2.0.0-dev.7.4.0.214930",
   "description": "A library for synthesizing scope objects.",
   "homepage": "https://fluidframework.com",
   "repository": {
@@ -51,21 +51,22 @@
     "temp-directory": "nyc/.nyc_output"
   },
   "dependencies": {
-    "@fluidframework/core-utils": "2.0.0-dev.7.3.0.211848"
+    "@fluidframework/core-utils": "2.0.0-dev.7.4.0.214930"
   },
   "devDependencies": {
-    "@fluid-tools/build-cli": "0.28.0-210888",
+    "@fluid-tools/build-cli": "^0.28.0",
     "@fluidframework/build-common": "^2.0.3",
-    "@fluidframework/build-tools": "0.28.0-210888",
-    "@fluidframework/core-interfaces": "2.0.0-dev.7.3.0.211848",
-    "@fluidframework/datastore": "2.0.0-dev.7.3.0.211848",
+    "@fluidframework/build-tools": "^0.28.0",
+    "@fluidframework/core-interfaces": "2.0.0-dev.7.4.0.214930",
+    "@fluidframework/datastore": "2.0.0-dev.7.4.0.214930",
     "@fluidframework/eslint-config-fluid": "^3.1.0",
-    "@fluidframework/mocha-test-setup": "2.0.0-dev.7.3.0.211848",
+    "@fluidframework/mocha-test-setup": "2.0.0-dev.7.4.0.214930",
     "@fluidframework/synthesize-previous": "npm:@fluidframework/synthesize@2.0.0-internal.7.2.0",
     "@microsoft/api-extractor": "^7.38.3",
     "@types/mocha": "^9.1.1",
     "@types/node": "^16.18.38",
     "c8": "^7.7.1",
+    "copyfiles": "^2.4.1",
     "cross-env": "^7.0.3",
     "eslint": "~8.50.0",
     "mocha": "^10.2.0",
@@ -77,14 +78,29 @@
     "tsc-multi": "^1.1.0",
     "typescript": "~5.1.6"
   },
+  "fluidBuild": {
+    "tasks": {
+      "build:docs": {
+        "dependsOn": [
+          "...",
+          "api-extractor:commonjs",
+          "api-extractor:esnext"
+        ],
+        "script": false
+      }
+    }
+  },
   "typeValidation": {
     "broken": {}
   },
   "scripts": {
+    "api": "fluid-build . --task api",
+    "api-extractor:commonjs": "api-extractor run --local",
+    "api-extractor:esnext": "copyfiles -u 1 \"dist/**/*-@(alpha|beta|public|untrimmed).d.ts\" lib",
     "build": "fluid-build . --task build",
     "build:commonjs": "fluid-build . --task commonjs",
     "build:compile": "fluid-build . --task compile",
-    "build:docs": "api-extractor run --local",
+    "build:docs": "fluid-build . --task api",
     "build:esnext": "tsc-multi --config ../../../common/build/build-common/tsc-multi.esm.json",
     "build:test": "tsc-multi --config ./tsc-multi.test.json",
     "ci:build:docs": "api-extractor run",
@@ -94,8 +110,8 @@
     "format": "npm run prettier:fix",
     "lint": "npm run prettier && npm run eslint",
     "lint:fix": "npm run prettier:fix && npm run eslint:fix",
-    "prettier": "prettier --check . --ignore-path ../../../.prettierignore",
-    "prettier:fix": "prettier --write . --ignore-path ../../../.prettierignore",
+    "prettier": "prettier --check . --cache --ignore-path ../../../.prettierignore",
+    "prettier:fix": "prettier --write . --cache --ignore-path ../../../.prettierignore",
     "test": "npm run test:mocha",
     "test:coverage": "c8 npm test",
     "test:mocha": "mocha --ignore \"dist/test/types/*\" --recursive dist/test -r node_modules/@fluidframework/mocha-test-setup",