import { Exception } from '@angularity/core';
import * as i0 from '@angular/core';
import { ProviderToken, Injector, EnvironmentProviders } from '@angular/core';
import { Observable } from 'rxjs';

/**
 * Name-value pairs that represent the small, repeated design decisions that make
 * up a design system's visual style.
 * @see https://m3.material.io/foundations/design-tokens/overview
 * @see `TokenBuilder`
 */
interface ThemeTokens {
    [name: string]: string;
}
/**
 * Registry for active theme tokens in the current application.
 *
 * On server, the tokens will be written to `TransferState`, and
 * can be later reused on browser via the `transfer` method.
 *
 * @remarks
 * By default, uses `InMemoryThemeTokenRegistry`
 * decorated with `WriteTokensToRootCssVariables`.
 */
declare abstract class ThemeTokenRegistry {
    /**
     * Retrieve the value of a theme token.
     * @param name the name of the theme token
     * @returns the value if registered, or `null` if not found
     */
    abstract get(name: string): string | null;
    /**
     * Retrieve all theme tokens.
     * @returns copy of all theme tokens
     */
    abstract getAll(): ThemeTokens;
    /**
     * Define a new value for a theme token. Duplicate defines overwrite the
     * previous value.
     * @param name the name of the theme token
     * @param value new value for the theme token
     */
    abstract set(name: string, value: string | null): void;
    /**
     * Define all theme tokens, replacing all existing tokens.
     * @param tokens new theme tokens
     */
    abstract setAll(tokens: ThemeTokens): void;
    /**
     * Transfer theme tokens from `TransferState` to this registry,
     * if `TransferState` is available and contains theme tokens.
     * This will clear all existing tokens in this registry.
     * @returns `true` if tokens are transferred, `false` otherwise
     */
    abstract transfer(): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<ThemeTokenRegistry, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ThemeTokenRegistry>;
}
/**
 * Exception thrown when a theme token is not found in the registry.
 */
declare class ThemeTokenNotFoundException extends Exception {
    constructor(name: string);
}
/**
 * Implementation of `ThemeTokenRegistry` that
 * stores theme tokens in memory.
 */
declare class InMemoryThemeTokenRegistry implements ThemeTokenRegistry {
    #private;
    constructor();
    get(name: string): string | null;
    getAll(): ThemeTokens;
    set(name: string, value: string | null): void;
    setAll(tokens: ThemeTokens): void;
    transfer(): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<InMemoryThemeTokenRegistry, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<InMemoryThemeTokenRegistry>;
}
/**
 * Decorator of `ThemeTokenRegistry` that
 * writes theme tokens to the root element as CSS variables.
 *
 * - On server, the tokens will be written to
 * the root element's style properties as CSS variables.
 * - On modern browser, the tokens will be written to
 * a constructed `CSSStyleSheet` object adopted by the document.
 * - On legacy browser, the tokens will be written to
 * a `<style>` element appended to the document head.
 */
declare class WriteTokensToRootCssVariables implements ThemeTokenRegistry {
    #private;
    constructor(delegate: ThemeTokenRegistry);
    get(name: string): string | null;
    getAll(): ThemeTokens;
    set(name: string, value: string | null): void;
    setAll(tokens: ThemeTokens): void;
    transfer(): boolean;
}

/**
 * Responsible for generating a group of theme tokens based on a configuration.
 *
 * @remarks
 * The generic type parameter declares the acceptable configuration type.
 *
 * @remarks
 * This package contains a built-in implementation: `VanillaBuilder`.
 *
 * @example
 *  ```ts
 *  export interface MyThemeConfig {
 *    primaryColor: string;
 *  }
 *  export class MyTokenBuilder implements TokenBuilder<MyThemeConfig> {
 *    build(context: TokenBuilderContext<MyThemeConfig>): ThemeTokens {
 *      return {
 *        [`${context.name}-primary-color`]: context.config.primaryColor,
 *      };
 *    }
 *  }
 *  ```
 */
interface TokenBuilder<Config> {
    /**
     * Generate a group of theme tokens based on a configuration.
     */
    build(context: TokenBuilderContext<Config>): ThemeTokens;
}
/**
 * Contextual information required for generating theme tokens.
 * @see `TokenBuilder`
 */
interface TokenBuilderContext<Config> {
    /**
     * Name assigned to this theme builder. May or may not be included in
     * generated token names, depending on the implementation.
     */
    name: string;
    /**
     * Options that affects the behavior of the token generation.
     */
    config: Config;
}
/**
 * Utility type that extracts the accepted configuration type from a
 * `TokenBuilder` type.
 */
type TokenBuilderConfigOf<Builder extends TokenBuilder<any>> = Builder extends TokenBuilder<infer Config> ? Config : never;

interface VanillaBuilderConfig extends ThemeTokens {
}
/**
 * An implementation of `TokenBuilder` that simply accepts an object of
 * pre-defined theme tokens as configuration and returns them as is when
 * requested to generate tokens.
 *
 * @remarks
 * The `name` assigned to this builder will be used as the prefix for the
 * tokens. An empty string can be used to avoid prefixing the tokens.
 *
 * @example
 *  ```ts
 *  scheduleTokenBuild("tokens-", VanillaBuilder, {
 *    "primary-color": "#ff0000",
 *  }),
 *  ```
 *
 * @example
 *  ```ts
 *  scheduleTokenBuild("", VanillaBuilder, {
 *    "primary-color": "#ff0000",
 *  }),
 *  ```
 */
declare class VanillaBuilder implements TokenBuilder<VanillaBuilderConfig> {
    build(context: TokenBuilderContext<VanillaBuilderConfig>): ThemeTokens;
    static ɵfac: i0.ɵɵFactoryDeclaration<VanillaBuilder, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<VanillaBuilder>;
}

/**
 * Represents a token generation specification, which specifies the target `TokenBuilder`
 * and relevant configurations to be passed to the builder.
 * @see `scheduleTokenBuild`
 */
interface TokenBuild {
    /**
     * The name that will be passed to the theme builder.
     */
    name: string;
    /**
     * The token that can be used to retrieve the theme builder instance from
     * the injector.
     */
    builder: ProviderToken<TokenBuilder<any>>;
    /**
     * The configuration object that will be passed to the theme builder.
     */
    config: unknown;
}
/**
 * Creates a token generation specification, which specifies the target `TokenBuilder`
 * and relevant configurations to be passed to the builder.
 * @param name The name that will be passed to the theme builder.
 * @param builder The token that can be used to retrieve the theme builder
 * @param config The configuration object that will be passed to the theme builder.
 * @returns
 *
 * @see `provideTheme`
 *
 * @usageNotes
 *
 * A builder class can be passed to the `builder` parameter because constructor
 * classes are valid tokens for dependency injection. It is worthy noting that
 * you need to make sure that there is a provider for the token. This function
 * does not register providers for the token.
 *
 *  ```ts
 *  provide({ token: ColorBuilder, useClass: MyColorBuilder }),
 *  ```
 *  ```ts
 *  scheduleTokenBuild('color', ColorBuilder, { primaryColor: PRIMARY_COLOR }),
 *  ```
 *
 * An observable can be passed as the `config` parameter, in which case the
 * theme is expected to be updated on every value emission.
 *
 *  ```ts
 *  scheduleTokenBuild(
 *    'color',
 *    ColorBuilder,
 *    observePreferredColorScheme().pipe(
 *      map((isDark) => ({ primaryColor: PRIMARY_COLOR, dark: isDark })),
 *    ),
 *  );
 *  ```
 *
 * In order to gain access to the injection context, use the `defer` RxJS
 * operator, which defers the invocation of the observable factory until
 * the observable is subscribed during the environment initialization, where
 * an injection context is available.
 *
 * ```ts
 * scheduleTokenBuild(
 *   'color',
 *   ColorBuilder,
 *   defer((schemeObserver = inject(PreferredColorSchemeObserver)) =>
 *     schemeObserver
 *       .observe()
 *       .pipe(map((isDark) => ({ primaryColor: PRIMARY_COLOR, dark: isDark }))),
 *   ),
 * );
 * ```
 */
declare function scheduleTokenBuild<Builder extends TokenBuilder<any>>(name: string, builder: ProviderToken<Builder>, config: TokenBuilderConfigOf<Builder> | Observable<TokenBuilderConfigOf<Builder>>): Observable<TokenBuild>;

/**
 * Specifications about how a visual theme can be generated.
 */
interface Theme {
    readonly spec: Observable<TokenBuild[]>;
}
/**
 * Create a `Theme` object from a list of `TokenBuild` specifications.
 */
declare function createTheme(...builds: Observable<TokenBuild>[]): Theme;
/**
 * Consume a `Theme` object to generate a set of theme tokens.
 */
declare function buildTheme(injector: Injector, theme: Theme): Observable<ThemeTokens>;

/**
 * Make providers that consume the given theme.
 *
 * The application initialization process will be blocked until the
 * the initial theme tokens are available. The initial theme tokens
 * might be the pre-built tokens from the server (SSR environment),
 * or be built from scratch if no server tokens exist.
 *
 * For CSR applications, async theme is discouraged, since it slows
 * down application bootstrap. For SSR applications, using async theme
 * can help reduce the size of the initial bundle as well as accelerate
 * bootstrap, because the theme is pre-built on server and immediately
 * available on browser.
 *
 * @example
 * Theme File:
 *  ```ts
 *  export const appTheme = createTheme(
 *    scheduleTokenBuild("typography", TypographyBuilder, {
 *      font: "OpenSans"
 *    }),
 *    scheduleTokenBuild(
 *      'color',
 *      ColorBuilder,
 *      defer((schemeObserver = inject(PreferredColorSchemeObserver)) =>
 *        schemeObserver
 *          .observe()
 *          .pipe(map((isDark) => ({ primaryColor: PRIMARY_COLOR, dark: isDark }))),
 *      ),
 *    ),
 *  )
 *  ```
 *  ```ts
 *  provideTheme(appTheme) // sync
 *  provideTheme(import('./app.theme.ts').then(m => m.appTheme)) // async
 *  ```
 *
 * @see `TokenBuilder`
 * @see `scheduleTokenBuild`
 */
declare function provideTheme(theme: Theme | Promise<Theme>): EnvironmentProviders;

export { InMemoryThemeTokenRegistry, ThemeTokenNotFoundException, ThemeTokenRegistry, VanillaBuilder, WriteTokensToRootCssVariables, buildTheme, createTheme, provideTheme, scheduleTokenBuild };
export type { Theme, ThemeTokens, TokenBuild, TokenBuilder, TokenBuilderConfigOf, TokenBuilderContext, VanillaBuilderConfig };