@angular-wave/angular.ts 0.7.0-beta.0 → 0.7.1

package/@types/core/location/location.d.ts

@@ -89,7 +89,7 @@ export class Location {
    *
    * Return host of current URL.
    *
-   * Note: compared to the non-AngularJS version `location.host` which returns `hostname:port`, this returns the `hostname` portion only.
+   * Note: compared to the non-AngularTS version `location.host` which returns `hostname:port`, this returns the `hostname` portion only.
    *
    *
    * @return {string} host of current URL.

package/@types/core/parse/interface.d.ts

@@ -0,0 +1,79 @@
+import type { DecoratedASTNode } from "./interpreter.js";
+import type { Scope } from "../scope/scope.js";
+/**
+ * Describes metadata and behavior for a compiled AngularTS expression.
+ */
+export interface CompiledExpressionProps {
+  /** Indicates if the expression is a literal. */
+  literal: boolean;
+  /** Indicates if the expression is constant. */
+  constant: boolean;
+  /** Optional flag for pure expressions. */
+  isPure?: boolean;
+  /** Indicates if the expression should be evaluated only once. */
+  oneTime: boolean;
+  /** AST node decorated with metadata. */
+  decoratedNode: DecoratedASTNode;
+  /**
+   * Optional custom watch delegate function for the expression.
+   * @param scope - The current scope.
+   * @param listener - A listener function.
+   * @param equalityCheck - Whether to use deep equality.
+   * @param expression - The compiled expression or string.
+   */
+  $$watchDelegate?: (
+    scope: Scope,
+    listener: Function,
+    equalityCheck: boolean,
+    expression: CompiledExpression | string | ((scope: Scope) => any),
+  ) => any;
+  /** Expression inputs; may be an array or a function. */
+  inputs: any[] | Function;
+  /**
+   * Optional assign function for two-way binding.
+   * Assigns a value to a context.
+   * If value is not provided, may return the getter.
+   */
+  assign?: (context: any, value: any) => any;
+}
+/**
+ * Expression function with context and optional locals/assign.
+ * Evaluates the compiled expression.
+ */
+export type CompiledExpressionFunction = (
+  context?: Scope,
+  locals?: object,
+  assign?: any,
+) => any;
+/**
+ * A compiled expression that is both a function and includes expression metadata.
+ */
+export type CompiledExpression = CompiledExpressionFunction &
+  CompiledExpressionProps;
+/**
+ * Map used for expressions that watch specific object keys.
+ */
+export interface CompiledExpressionHandlerMap {
+  /** Indicates if the expression is a literal. */
+  literal: boolean;
+  /** Indicates if the expression is constant. */
+  constant: boolean;
+  /** Optional flag for pure expressions. */
+  isPure?: boolean;
+  /** Indicates if the expression should be evaluated only once. */
+  oneTime: boolean;
+  /** A map of property keys to observe. */
+  keyMap: Map<string, Function>;
+}
+/**
+ * Parses a string or expression function into a compiled expression.
+ * @param expression - The input expression (string or function).
+ * @param interceptorFn - Optional value transformer.
+ * @param expensiveChecks - Whether to enable expensive change detection.
+ * @returns A compiled expression.
+ */
+export type ParseService = (
+  expression?: CompiledExpression | string | ((scope: Scope) => any),
+  interceptorFn?: (value: any, scope: Scope, locals: any) => any,
+  expensiveChecks?: boolean,
+) => CompiledExpression;

package/@types/core/parse/interpreter.d.ts

@@ -14,17 +14,21 @@ export class ASTInterpreter {
   /**
    * Compiles the AST into a function.
    * @param {import("./ast/ast").ASTNode} ast - The AST to compile.
-   * @returns {import("./parse").CompiledExpression}
+   * @returns {import("./interface.ts").CompiledExpression}
    */
-  compile(ast: any): any;
+  compile(ast: any): import("./interface.ts").CompiledExpression;
   /**
    * Recurses the AST nodes.
    * @param {import("./ast/ast").ASTNode} ast - The AST node.
    * @param {Object} [context] - The context.
    * @param {boolean|1} [create] - The create flag.
-   * @returns {import("./parse").CompiledExpressionFunction} The recursive function.
+   * @returns {import("./interface.ts").CompiledExpressionFunction} The recursive function.
    */
-  recurse(ast: any, context?: any, create?: boolean | 1): any;
+  recurse(
+    ast: any,
+    context?: any,
+    create?: boolean | 1,
+  ): import("./interface.ts").CompiledExpressionFunction;
   /**
    * Unary plus operation.
    * @param {function} argument - The argument function.
@@ -189,17 +193,24 @@ export class ASTInterpreter {
    * Returns the value of a literal.
    * @param {*} value - The literal value.
    * @param {Object} [context] - The context.
-   * @returns {function} The function returning the literal value.
+   * @returns {import("./interface.ts").CompiledExpressionFunction} The function returning the literal value.
    */
-  value(value: any, context?: any): Function;
+  value(
+    value: any,
+    context?: any,
+  ): import("./interface.ts").CompiledExpressionFunction;
   /**
    * Returns the value of an identifier.
    * @param {string} name - The identifier name.
    * @param {Object} [context] - The context.
    * @param {boolean|1} [create] - Whether to create the identifier if it does not exist.
-   * @returns {function} The function returning the identifier value.
+   * @returns {import("./interface.ts").CompiledExpressionFunction} The function returning the identifier value.
    */
-  identifier(name: string, context?: any, create?: boolean | 1): Function;
+  identifier(
+    name: string,
+    context?: any,
+    create?: boolean | 1,
+  ): import("./interface.ts").CompiledExpressionFunction;
   /**
    * Returns the value of a computed member expression.
    * @param {function} left - The left operand function.

package/@types/core/parse/parse.d.ts

@@ -1,42 +1,7 @@
-/**
- * @typedef {Object} CompiledExpressionProps
- * @property {boolean} literal - Indicates if the expression is a literal.
- * @property {boolean} constant - Indicates if the expression is constant.
- * @property {boolean} [isPure]
- * @property {boolean} oneTime
- * @property {import("./interpreter.js").DecoratedASTNode} decoratedNode
- * @property {function(import('../scope/scope.js').Scope, Function, boolean, CompiledExpression, string | ((scope:  import('../scope/scope.js').Scope) => any) | CompiledExpression): any} [$$watchDelegate]
- * @property {any[]|Function} inputs
- * @property {function(any, any): any} [assign] - Assigns a value to a context. If value is not provided,
- */
-/**
- * @typedef {Object} CompiledExpressionHandlerMap
- * @property {boolean} literal - Indicates if the expression is a literal.
- * @property {boolean} constant - Indicates if the expression is constant.
- * @property {boolean} [isPure]
- * @property {boolean} oneTime
- * @property {Map<string, Function>} keyMap - property keys to observe
- */
-/**
- * @typedef {Function} CompiledExpressionFunction
- * @param {import('../scope/scope.js').Scope} context - An object against which any expressions embedded in the strings are evaluated against (typically a scope object).
- * @param {object} [locals] - local variables context object, useful for overriding values in `context`.
- * @param {any} [assign]
- * @returns {any}
- * undefined is gonna be used since the implementation
- * does not check the parameter. Let's force a value for consistency. If consumer
- * wants to undefine it, pass the undefined value explicitly.
- */
-/**
- * @typedef {CompiledExpressionFunction & CompiledExpressionProps} CompiledExpression
- */
-/**
- * @typedef {function(CompiledExpression|string|function(import('../scope/scope.js').Scope):any, function(any, import('../scope/scope.js').Scope, any):any=, boolean=): CompiledExpression} ParseService
- */
 export function ParseProvider(): void;
 export class ParseProvider {
   /**
-   * Allows defining the set of characters that are allowed in AngularJS expressions. The function
+   * Allows defining the set of characters that are allowed in AngularTS expressions. The function
    * `identifierStart` will get called to know if a given character is a valid character to be the
    * first character for an identifier. The function `identifierContinue` will get called to know if
    * a given character is a valid character to be a follow-up identifier character. The functions
@@ -59,7 +24,7 @@ export class ParseProvider {
     identifierStart?: (arg0: any) => boolean,
     identifierContinue?: (arg0: any) => boolean,
   ) => ParseProvider;
-  $get: (string | (($filter: (any: any) => any) => ParseService))[];
+  $get: (string | (($filter: (any: any) => any) => any))[];
 }
 export function constantWatchDelegate(
   scope: any,
@@ -67,60 +32,3 @@ export function constantWatchDelegate(
   objectEquality: any,
   parsedExpression: any,
 ): any;
-export type CompiledExpressionProps = {
-  /**
-   * - Indicates if the expression is a literal.
-   */
-  literal: boolean;
-  /**
-   * - Indicates if the expression is constant.
-   */
-  constant: boolean;
-  isPure?: boolean;
-  oneTime: boolean;
-  decoratedNode: import("./interpreter.js").DecoratedASTNode;
-  $$watchDelegate?: (
-    arg0: import("../scope/scope.js").Scope,
-    arg1: Function,
-    arg2: boolean,
-    arg3: CompiledExpression,
-    arg4:
-      | string
-      | ((scope: import("../scope/scope.js").Scope) => any)
-      | CompiledExpression,
-  ) => any;
-  inputs: any[] | Function;
-  /**
-   * - Assigns a value to a context. If value is not provided,
-   */
-  assign?: (arg0: any, arg1: any) => any;
-};
-export type CompiledExpressionHandlerMap = {
-  /**
-   * - Indicates if the expression is a literal.
-   */
-  literal: boolean;
-  /**
-   * - Indicates if the expression is constant.
-   */
-  constant: boolean;
-  isPure?: boolean;
-  oneTime: boolean;
-  /**
-   * - property keys to observe
-   */
-  keyMap: Map<string, Function>;
-};
-export type CompiledExpressionFunction = Function;
-export type CompiledExpression = CompiledExpressionFunction &
-  CompiledExpressionProps;
-export type ParseService = (
-  arg0:
-    | CompiledExpression
-    | string
-    | ((arg0: import("../scope/scope.js").Scope) => any),
-  arg1:
-    | ((arg0: any, arg1: import("../scope/scope.js").Scope, arg2: any) => any)
-    | undefined,
-  arg2: boolean | undefined,
-) => CompiledExpression;

package/@types/core/parse/parser/parser.d.ts

@@ -22,9 +22,9 @@ export class Parser {
   /**
    *
    * @param {string} exp - Expression to be parsed
-   * @returns {import("../parse.js").CompiledExpression}
+   * @returns {import("../interface.ts").CompiledExpression}
    */
-  parse(exp: string): import("../parse.js").CompiledExpression;
+  parse(exp: string): import("../interface.ts").CompiledExpression;
   /**
    * @param {string} exp - Expression to be parsed
    * @returns {ParsedAST}

package/@types/core/pubsub/pubsub.d.ts

@@ -1,3 +1,19 @@
+/** @typedef {import('../../interface.js').ServiceProvider} ServiceProvider
+
+/**
+ * Configurable provider for an injectable event bus
+ * @implements {ServiceProvider}
+ */
+export class PubSubProvider implements ServiceProvider {
+  /**
+   * @type {PubSub}
+   */
+  eventBus: PubSub;
+  /**
+   * @returns {PubSub}
+   */
+  $get: () => PubSub;
+}
 export class PubSub {
   /**
    * Runs a function asynchronously.
@@ -162,3 +178,8 @@ export class PubSub {
   dispose(): void;
 }
 export const EventBus: PubSub;
+/**
+ * /**
+ * Configurable provider for an injectable event bus
+ */
+export type ServiceProvider = import("../../interface.js").ServiceProvider;

package/@types/core/sanitize/interface.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Sanitizer function that processes a URI string and optionally
+ * treats it as a media URL.
+ */
+export interface SanitizerFn {
+  (
+    uri: string | null | undefined,
+    isMediaUrl?: boolean,
+  ): string | null | undefined;
+}

package/@types/core/sanitize/sanitize-uri.d.ts

@@ -1,56 +1,43 @@
+/** @typedef {import('../../interface.ts').ServiceProvider} ServiceProvider } */
 /**
- *
- * @description
  * Private service to sanitize uris for links and images. Used by $compile.
+ * @implements {ServiceProvider}
  */
-export function SanitizeUriProvider(): void;
-export class SanitizeUriProvider {
+export class SanitizeUriProvider implements ServiceProvider {
   /**
-   * @description
-   * Retrieves or overrides the default regular expression that is used for determining trusted safe
-   * urls during a[href] sanitization.
-   *
-   * The sanitization is a security measure aimed at prevent XSS attacks via HTML anchor links.
-   *
-   * Any url due to be assigned to an `a[href]` attribute via interpolation is marked as requiring
-   * the $sce.URL security context. When interpolation occurs a call is made to `$sce.trustAsUrl(url)`
-   * which in turn may call `$$sanitizeUri(url, isMedia)` to sanitize the potentially malicious URL.
-   *
-   * If the URL matches the `aHrefSanitizationTrustedUrlList` regular expression, it is returned unchanged.
-   *
-   * If there is no match the URL is returned prefixed with `'unsafe:'` to ensure that when it is written
-   * to the DOM it is inactive and potentially malicious code will not be executed.
+   * @private
+   * @type {RegExp}
+   */
+  private _aHrefSanitizationTrustedUrlList;
+  /**
+   * @private
+   * @type {RegExp}
+   */
+  private _imgSrcSanitizationTrustedUrlList;
+  /**
+   * Retrieves or overrides the regexp used to trust URLs for a[href] sanitization.
    *
-   * @param {RegExp=} regexp New regexp to trust urls with.
-   * @returns {RegExp|SanitizeUriProvider} Current RegExp if called without value or self for
-   *    chaining otherwise.
+   * @param {RegExp=} regexp New regexp to trust URLs with.
+   * @returns {RegExp|SanitizeUriProvider} Current regexp if no param, or self for chaining.
    */
-  aHrefSanitizationTrustedUrlList: (
+  aHrefSanitizationTrustedUrlList(
     regexp?: RegExp | undefined,
-  ) => RegExp | SanitizeUriProvider;
+  ): RegExp | SanitizeUriProvider;
   /**
-   * @description
-   * Retrieves or overrides the default regular expression that is used for determining trusted safe
-   * urls during img[src] sanitization.
+   * Retrieves or overrides the regexp used to trust URLs for img[src] sanitization.
    *
-   * The sanitization is a security measure aimed at prevent XSS attacks via HTML image src links.
-   *
-   * Any URL due to be assigned to an `img[src]` attribute via interpolation is marked as requiring
-   * the $sce.MEDIA_URL security context. When interpolation occurs a call is made to
-   * `$sce.trustAsMediaUrl(url)` which in turn may call `$$sanitizeUri(url, isMedia)` to sanitize
-   * the potentially malicious URL.
-   *
-   * If the URL matches the `imgSrcSanitizationTrustedUrlList` regular expression, it is returned
-   * unchanged.
-   *
-   * If there is no match the URL is returned prefixed with `'unsafe:'` to ensure that when it is written
-   * to the DOM it is inactive and potentially malicious code will not be executed.
-   *
-   * @param {RegExp=} regexp New regexp to trust urls with.
-   * @returns {RegExp|SanitizeUriProvider} Current RegExp if called without value or self for chaining otherwise.
+   * @param {RegExp=} regexp New regexp to trust URLs with.
+   * @returns {RegExp|SanitizeUriProvider} Current regexp if no param, or self for chaining.
    */
-  imgSrcSanitizationTrustedUrlList: (
+  imgSrcSanitizationTrustedUrlList(
     regexp?: RegExp | undefined,
-  ) => RegExp | SanitizeUriProvider;
-  $get: () => (uri: any, isMediaUrl: any) => any;
+  ): RegExp | SanitizeUriProvider;
+  /**
+   * @returns {import("./interface.js").SanitizerFn} Sanitizer function.
+   */
+  $get(): import("./interface.js").SanitizerFn;
 }
+/**
+ * }
+ */
+export type ServiceProvider = import("../../interface.ts").ServiceProvider;

package/@types/core/sce/sce.d.ts

@@ -1,21 +1,119 @@
 export function escapeForRegexp(s: any): any;
 export function adjustMatcher(matcher: any): any;
+export function SceProvider(): void;
+export class SceProvider {
+  /**
+   * @param {boolean=} value If provided, then enables/disables SCE application-wide.
+   * @return {boolean} True if SCE is enabled, false otherwise.
+   *
+   * @description
+   * Enables/disables SCE and returns the current value.
+   */
+  enabled: (value?: boolean | undefined, ...args: any[]) => boolean;
+  $get: (string | (($parse: any, $sceDelegate: any) => any))[];
+}
+export namespace SCE_CONTEXTS {
+  let HTML: string;
+  let CSS: string;
+  let MEDIA_URL: string;
+  let URL: string;
+  let RESOURCE_URL: string;
+  let JS: string;
+}
+/**
+ * `$sceDelegate` is a service that is used by the `$sce` service to provide {@link ng.$sce Strict
+ * Contextual Escaping (SCE)} services to AngularTS.
+ *
+ * For an overview of this service and the functionnality it provides in AngularTS, see the main
+ * page for {@link ng.$sce SCE}. The current page is targeted for developers who need to alter how
+ * SCE works in their application, which shouldn't be needed in most cases.
+ *
+ * <div class="alert alert-danger">
+ * AngularTS strongly relies on contextual escaping for the security of bindings: disabling or
+ * modifying this might cause cross site scripting (XSS) vulnerabilities. For libraries owners,
+ * changes to this service will also influence users, so be extra careful and document your changes.
+ * </div>
+ *
+ * Typically, you would configure or override the {@link ng.$sceDelegate $sceDelegate} instead of
+ * the `$sce` service to customize the way Strict Contextual Escaping works in AngularTS.  This is
+ * because, while the `$sce` provides numerous shorthand methods, etc., you really only need to
+ * override 3 core functions (`trustAs`, `getTrusted` and `valueOf`) to replace the way things
+ * work because `$sce` delegates to `$sceDelegate` for these operations.
+ *
+ * Refer {@link ng.$sceDelegateProvider $sceDelegateProvider} to configure this service.
+ *
+ * The default instance of `$sceDelegate` should work out of the box with little pain.  While you
+ * can override it completely to change the behavior of `$sce`, the common case would
+ * involve configuring the {@link ng.$sceDelegateProvider $sceDelegateProvider} instead by setting
+ * your own trusted and banned resource lists for trusting URLs used for loading AngularTS resources
+ * such as templates.  Refer {@link ng.$sceDelegateProvider#trustedResourceUrlList
+ * $sceDelegateProvider.trustedResourceUrlList} and {@link
+ * ng.$sceDelegateProvider#bannedResourceUrlList $sceDelegateProvider.bannedResourceUrlList}
+ */
+/**
+ *
+ * The `$sceDelegateProvider` provider allows developers to configure the {@link ng.$sceDelegate
+ * $sceDelegate service}, used as a delegate for {@link ng.$sce Strict Contextual Escaping (SCE)}.
+ *
+ * The `$sceDelegateProvider` allows one to get/set the `trustedResourceUrlList` and
+ * `bannedResourceUrlList` used to ensure that the URLs used for sourcing AngularTS templates and
+ * other script-running URLs are safe (all places that use the `$sce.RESOURCE_URL` context). See
+ * {@link ng.$sceDelegateProvider#trustedResourceUrlList
+ * $sceDelegateProvider.trustedResourceUrlList} and
+ * {@link ng.$sceDelegateProvider#bannedResourceUrlList $sceDelegateProvider.bannedResourceUrlList},
+ *
+ * For the general details about this service in AngularTS, read the main page for {@link ng.$sce
+ * Strict Contextual Escaping (SCE)}.
+ *
+ * **Example**:  Consider the following case. <a name="example"></a>
+ *
+ * - your app is hosted at url `http://myapp.example.com/`
+ * - but some of your templates are hosted on other domains you control such as
+ *   `http://srv01.assets.example.com/`, `http://srv02.assets.example.com/`, etc.
+ * - and you have an open redirect at `http://myapp.example.com/clickThru?...`.
+ *
+ * Here is what a secure configuration for this scenario might look like:
+ *
+ * ```
+ *  angular.module('myApp', []).config(function($sceDelegateProvider) {
+ *    $sceDelegateProvider.trustedResourceUrlList([
+ *      // Allow same origin resource loads.
+ *      'self',
+ *      // Allow loading from our assets domain.  Notice the difference between * and **.
+ *      'http://srv*.assets.example.com/**'
+ *    ]);
+ *
+ *    // The banned resource URL list overrides the trusted resource URL list so the open redirect
+ *    // here is blocked.
+ *    $sceDelegateProvider.bannedResourceUrlList([
+ *      'http://myapp.example.com/clickThru**'
+ *    ]);
+ *  });
+ * ```
+ * Note that an empty trusted resource URL list will block every resource URL from being loaded, and will require
+ * you to manually mark each one as trusted with `$sce.trustAsResourceUrl`. However, templates
+ * requested by {@link ng.$templateRequest $templateRequest} that are present in
+ * {@link ng.$templateCache $templateCache} will not go through this check. If you have a mechanism
+ * to populate your templates in that cache at config time, then it is a good idea to remove 'self'
+ * from the trusted resource URL lsit. This helps to mitigate the security impact of certain types
+ * of issues, like for instance attacker-controlled `ng-includes`.
+ */
 /**
  * `$sceDelegate` is a service that is used by the `$sce` service to provide {@link ng.$sce Strict
- * Contextual Escaping (SCE)} services to AngularJS.
+ * Contextual Escaping (SCE)} services to AngularTS.
  *
- * For an overview of this service and the functionnality it provides in AngularJS, see the main
+ * For an overview of this service and the functionnality it provides in AngularTS, see the main
  * page for {@link ng.$sce SCE}. The current page is targeted for developers who need to alter how
  * SCE works in their application, which shouldn't be needed in most cases.
  *
  * <div class="alert alert-danger">
- * AngularJS strongly relies on contextual escaping for the security of bindings: disabling or
+ * AngularTS strongly relies on contextual escaping for the security of bindings: disabling or
  * modifying this might cause cross site scripting (XSS) vulnerabilities. For libraries owners,
  * changes to this service will also influence users, so be extra careful and document your changes.
  * </div>
  *
  * Typically, you would configure or override the {@link ng.$sceDelegate $sceDelegate} instead of
- * the `$sce` service to customize the way Strict Contextual Escaping works in AngularJS.  This is
+ * the `$sce` service to customize the way Strict Contextual Escaping works in AngularTS.  This is
  * because, while the `$sce` provides numerous shorthand methods, etc., you really only need to
  * override 3 core functions (`trustAs`, `getTrusted` and `valueOf`) to replace the way things
  * work because `$sce` delegates to `$sceDelegate` for these operations.
@@ -25,7 +123,7 @@ export function adjustMatcher(matcher: any): any;
  * The default instance of `$sceDelegate` should work out of the box with little pain.  While you
  * can override it completely to change the behavior of `$sce`, the common case would
  * involve configuring the {@link ng.$sceDelegateProvider $sceDelegateProvider} instead by setting
- * your own trusted and banned resource lists for trusting URLs used for loading AngularJS resources
+ * your own trusted and banned resource lists for trusting URLs used for loading AngularTS resources
  * such as templates.  Refer {@link ng.$sceDelegateProvider#trustedResourceUrlList
  * $sceDelegateProvider.trustedResourceUrlList} and {@link
  * ng.$sceDelegateProvider#bannedResourceUrlList $sceDelegateProvider.bannedResourceUrlList}
@@ -36,13 +134,13 @@ export function adjustMatcher(matcher: any): any;
  * $sceDelegate service}, used as a delegate for {@link ng.$sce Strict Contextual Escaping (SCE)}.
  *
  * The `$sceDelegateProvider` allows one to get/set the `trustedResourceUrlList` and
- * `bannedResourceUrlList` used to ensure that the URLs used for sourcing AngularJS templates and
+ * `bannedResourceUrlList` used to ensure that the URLs used for sourcing AngularTS templates and
  * other script-running URLs are safe (all places that use the `$sce.RESOURCE_URL` context). See
  * {@link ng.$sceDelegateProvider#trustedResourceUrlList
  * $sceDelegateProvider.trustedResourceUrlList} and
  * {@link ng.$sceDelegateProvider#bannedResourceUrlList $sceDelegateProvider.bannedResourceUrlList},
  *
- * For the general details about this service in AngularJS, read the main page for {@link ng.$sce
+ * For the general details about this service in AngularTS, read the main page for {@link ng.$sce
  * Strict Contextual Escaping (SCE)}.
  *
  * **Example**:  Consider the following case. <a name="example"></a>
@@ -78,7 +176,6 @@ export function adjustMatcher(matcher: any): any;
  * from the trusted resource URL lsit. This helps to mitigate the security impact of certain types
  * of issues, like for instance attacker-controlled `ng-includes`.
  */
-export function SceDelegateProvider(): void;
 export class SceDelegateProvider {
   SCE_CONTEXTS: {
     HTML: string;
@@ -136,7 +233,7 @@ export class SceDelegateProvider {
   $get: (
     | string
     | ((
-        $injector: any,
+        $injector: import("../../core/di/internal-injector.js").InjectorService,
         $$sanitizeUri: any,
         $exceptionHandler: ErrorHandler,
       ) => {
@@ -146,27 +243,4 @@ export class SceDelegateProvider {
       })
   )[];
 }
-export function SceProvider(): void;
-export class SceProvider {
-  /**
-   * @param {boolean=} value If provided, then enables/disables SCE application-wide.
-   * @return {boolean} True if SCE is enabled, false otherwise.
-   *
-   * @description
-   * Enables/disables SCE and returns the current value.
-   */
-  enabled: (value?: boolean | undefined, ...args: any[]) => boolean;
-  $get: (
-    | string
-    | (($parse: any, $sceDelegate: any, $exceptionHandler: any) => any)
-  )[];
-}
-export namespace SCE_CONTEXTS {
-  let HTML: string;
-  let CSS: string;
-  let MEDIA_URL: string;
-  let URL: string;
-  let RESOURCE_URL: string;
-  let JS: string;
-}
-export type ErrorHandler = import("../exception-handler.js").ErrorHandler;
+export type ErrorHandler = import("../error-handler.ts").ErrorHandler;