@discourse/types 0.0.1 → 0.0.2

package/external-types/ember-source/types/stable/@ember/routing/lib/controller_for.d.ts

@@ -0,0 +1,16 @@
+declare module '@ember/routing/lib/controller_for' {
+    import type { Container } from "@ember/-internals/container";
+    import type { FactoryClass, InternalFactory } from "@ember/-internals/owner";
+    import type { RegisterOptions } from "@ember/owner";
+    /**
+      @module @ember/routing
+    */
+    /**
+      Finds a controller instance.
+
+      @for Ember
+      @method controllerFor
+      @private
+    */
+    export default function controllerFor(container: Container, controllerName: string, lookupOptions: RegisterOptions): InternalFactory<object, FactoryClass> | object | undefined;
+}

package/external-types/ember-source/types/stable/@ember/routing/lib/dsl.d.ts

@@ -0,0 +1,52 @@
+declare module '@ember/routing/lib/dsl' {
+    import type { InternalFactory } from "@ember/-internals/owner";
+    import type { MatchCallback } from "route-recognizer";
+    import type { EngineInfo, EngineRouteInfo } from "@ember/routing/lib/engines";
+    export interface RouteOptions {
+        path?: string;
+        resetNamespace?: boolean;
+        serialize?: (model: {}, params: string[]) => {
+            [key: string]: unknown | undefined;
+        };
+        overrideNameAssertion?: boolean;
+    }
+    export interface MountOptions {
+        path?: string;
+        as?: string;
+        resetNamespace?: boolean;
+    }
+    export interface DSLCallback {
+        (this: DSL): void;
+    }
+    export interface DSL {
+        route(name: string): void;
+        route(name: string, callback: DSLCallback): void;
+        route(name: string, options: RouteOptions): void;
+        route(name: string, options: RouteOptions, callback: DSLCallback): void;
+        mount(name: string): void;
+        mount(name: string, options: MountOptions): void;
+    }
+    export interface DSLImplOptions {
+        enableLoadingSubstates: boolean;
+        engineInfo?: EngineInfo;
+        addRouteForEngine(name: string, routeOptions: EngineRouteInfo): void;
+        resolveRouteMap(name: string): InternalFactory<any, any>;
+    }
+    export default class DSLImpl implements DSL {
+        parent: string | null;
+        matches: Array<Object | undefined>;
+        enableLoadingSubstates: boolean;
+        explicitIndex: boolean;
+        options: DSLImplOptions;
+        constructor(name: string | null | undefined, options: DSLImplOptions);
+        route(name: string): void;
+        route(name: string, callback: DSLCallback): void;
+        route(name: string, options: RouteOptions): void;
+        route(name: string, options: RouteOptions, callback: DSLCallback): void;
+        push(url: string, name: string, callback?: MatchCallback, serialize?: (model: {}, params: string[]) => {
+            [key: string]: unknown | undefined;
+        }): void;
+        generate(): MatchCallback;
+        mount(_name: string, options?: MountOptions): void;
+    }
+}

package/external-types/ember-source/types/stable/@ember/routing/lib/engines.d.ts

@@ -0,0 +1,14 @@
+declare module '@ember/routing/lib/engines' {
+    export interface EngineInfo {
+        name: string;
+        instanceId: number;
+        mountPoint: string;
+        fullName: string;
+    }
+    export interface EngineRouteInfo extends EngineInfo {
+        localFullName: string;
+        serializeMethod?: (model: {}, params: string[]) => {
+            [key: string]: unknown | undefined;
+        };
+    }
+}

package/external-types/ember-source/types/stable/@ember/routing/lib/generate_controller.d.ts

@@ -0,0 +1,25 @@
+declare module '@ember/routing/lib/generate_controller' {
+    import type { InternalFactory, default as Owner } from "@ember/-internals/owner";
+    import Controller from "@ember/controller";
+    /**
+     @module @ember/routing
+    */
+    /**
+      Generates a controller factory
+
+      @for Ember
+      @method generateControllerFactory
+      @private
+    */
+    export function generateControllerFactory(owner: Owner, controllerName: string): InternalFactory<{}>;
+    /**
+      Generates and instantiates a controller extending from `controller:basic`
+      if present, or `Controller` if not.
+
+      @for Ember
+      @method generateController
+      @private
+      @since 1.3.0
+    */
+    export default function generateController(owner: Owner, controllerName: string): Controller;
+}

package/external-types/ember-source/types/stable/@ember/routing/lib/location-utils.d.ts

@@ -0,0 +1,29 @@
+declare module '@ember/routing/lib/location-utils' {
+    /**
+      @private
+
+      Returns the current `location.pathname`, normalized for IE inconsistencies.
+    */
+    export function getPath(location: Location): string;
+    /**
+      @private
+
+      Returns the current `location.search`.
+    */
+    export function getQuery(location: Location): string;
+    /**
+      @private
+
+      Returns the hash or empty string
+    */
+    export function getHash(location: Location): string;
+    export function getFullPath(location: Location): string;
+    export function getOrigin(location: Location): string;
+    /**
+      Replaces the current location, making sure we explicitly include the origin
+      to prevent redirecting to a different origin.
+
+      @private
+    */
+    export function replacePath(location: Location, path: string): void;
+}

package/external-types/ember-source/types/stable/@ember/routing/lib/query_params.d.ts

@@ -0,0 +1,7 @@
+declare module '@ember/routing/lib/query_params' {
+    export default class QueryParams {
+        values: null | object;
+        isQueryParams: boolean;
+        constructor(values?: null);
+    }
+}

package/external-types/ember-source/types/stable/@ember/routing/lib/route-info.d.ts

@@ -0,0 +1,3 @@
+declare module '@ember/routing/lib/route-info' {
+    export type { RouteInfo, RouteInfoWithAttributes } from "router_js";
+}

package/external-types/ember-source/types/stable/@ember/routing/lib/router_state.d.ts

@@ -0,0 +1,13 @@
+declare module '@ember/routing/lib/router_state' {
+    import type { ModelFor, TransitionState } from "router_js";
+    import type Router from "router_js";
+    import type Route from "@ember/routing/route";
+    import type EmberRouter from "@ember/routing/router";
+    export default class RouterState {
+        router: Router<Route>;
+        emberRouter: EmberRouter;
+        routerJsState: TransitionState<Route>;
+        constructor(emberRouter: EmberRouter, router: Router<Route>, routerJsState: TransitionState<Route>);
+        isActiveIntent(routeName: string, models: ModelFor<Route>[], queryParams?: Record<string, unknown>): boolean;
+    }
+}

package/external-types/ember-source/types/stable/@ember/routing/lib/routing-service.d.ts

@@ -0,0 +1,35 @@
+declare module '@ember/routing/lib/routing-service' {
+    /**
+    @module ember
+    */
+    import Service from "@ember/service";
+    import type { ModelFor } from "router_js";
+    import type Route from "@ember/routing/route";
+    import EmberRouter from "@ember/routing/router";
+    import type RouterState from "@ember/routing/lib/router_state";
+    import { ROUTER } from "@ember/routing/router-service";
+    /**
+      The Routing service is used by LinkTo, and provides facilities for
+      the component/view layer to interact with the router.
+
+      This is a private service for internal usage only. For public usage,
+      refer to the `Router` service.
+
+      @private
+      @class RoutingService
+    */
+    export default class RoutingService<R extends Route> extends Service {
+        targetState: EmberRouter["targetState"];
+        currentState: EmberRouter["currentState"];
+        currentRouteName: EmberRouter["currentRouteName"];
+        currentPath: EmberRouter["currentPath"];
+        [ROUTER]?: EmberRouter;
+        get router(): EmberRouter;
+        hasRoute(routeName: string): boolean;
+        transitionTo(routeName: string, models: ModelFor<R>[], queryParams: Record<string, unknown>, shouldReplace: boolean): import("router_js").Transition;
+        normalizeQueryParams(routeName: string, models: ModelFor<R>[], queryParams: Record<string, unknown>): void;
+        _generateURL(routeName: string, models: ModelFor<R>[], queryParams: Record<string, unknown>): string;
+        generateURL(routeName: string, models: ModelFor<R>[], queryParams: Record<string, unknown>): string | undefined;
+        isActiveForRoute(contexts: ModelFor<R>[], queryParams: Record<string, unknown> | undefined, routeName: string, routerState: RouterState): boolean;
+    }
+}

package/external-types/ember-source/types/stable/@ember/routing/lib/utils.d.ts

@@ -0,0 +1,37 @@
+declare module '@ember/routing/lib/utils' {
+    import type { ControllerQueryParam, ControllerQueryParamType } from "@ember/controller";
+    import type Router from "router_js";
+    import type { ExtendedInternalRouteInfo } from "@ember/routing/route";
+    import type Route from "@ember/routing/route";
+    import type EmberRouter from "@ember/routing/router";
+    export type ExpandedControllerQueryParam = {
+        as: string | null;
+        scope: string;
+        type?: ControllerQueryParamType;
+    };
+    export type NamedRouteArgs = [routeNameOrUrl: string, ...modelsAndOptions: [...unknown[], RouteOptions]] | [routeNameOrUrl: string, ...models: unknown[]];
+    export type UnnamedRouteArgs = [...modelsAndOptions: [...unknown[], RouteOptions]] | [...models: unknown[]] | [options: RouteOptions];
+    export type RouteArgs = NamedRouteArgs | UnnamedRouteArgs;
+    type ExtractedArgs = {
+        routeName: string | undefined;
+        models: unknown[];
+        queryParams: Record<string, unknown>;
+    };
+    export type RouteOptions = {
+        queryParams: Record<string, unknown>;
+    };
+    export function extractRouteArgs(args: RouteArgs): ExtractedArgs;
+    export function getActiveTargetName(router: Router<Route>): string;
+    export function stashParamNames(
+        router: EmberRouter,
+        routeInfos: Array<ExtendedInternalRouteInfo<Route>> & {
+            _namesStashed?: boolean;
+        }
+    ): void;
+    export function calculateCacheKey(prefix: string, parts: string[] | undefined, values: {} | null): string;
+    export function normalizeControllerQueryParams(queryParams: Readonly<ControllerQueryParam[]>): Record<string, ExpandedControllerQueryParam>;
+    export function resemblesURL(str: unknown): str is string;
+    export function prefixRouteNameArg<T extends NamedRouteArgs | UnnamedRouteArgs>(route: Route, args: T): T;
+    export function shallowEqual<A extends object, B extends object>(a: A, b: B): boolean;
+    export {};
+}

package/external-types/ember-source/types/stable/@ember/routing/location-ext.d.ts

@@ -0,0 +1,18 @@
+// This module provides an 'extension' to the `@ember/routing/location` module
+// from the `@ember/routing` package, so that users can rely on
+// `owner.lookup('location:hash')` type checking and returning `HashLocation`
+// (and the same for other location types). Our type publishing infrastructure
+// will pass it through unchanged, so end users will get this extension.
+
+import '@ember/routing/location';
+import type HashLocation from '@ember/routing/hash-location';
+import type HistoryLocation from '@ember/routing/history-location';
+import type NoneLocation from '@ember/routing/none-location';
+
+declare module '@ember/routing/location' {
+  interface Registry {
+    hash: HashLocation;
+    history: HistoryLocation;
+    none: NoneLocation;
+  }
+}

package/external-types/ember-source/types/stable/@ember/routing/location.d.ts

@@ -0,0 +1,121 @@
+declare module '@ember/routing/location' {
+    /**
+      @module @ember/routing/location
+    */
+    /**
+      `Location` defines an interface to be implemented by `location` APIs. It is
+      not user-constructible; the only valid way to get a `Location` is via one of
+      its concrete implementations.
+
+      ## Implementations
+
+      You can pass an implementation name (`hash`, `history`, `none`) to force a
+      particular implementation to be used in your application.
+
+      - See [HashLocation](/ember/release/classes/HashLocation).
+      - See [HistoryLocation](/ember/release/classes/HistoryLocation).
+      - See [NoneLocation](/ember/release/classes/NoneLocation).
+
+      ## Location API
+
+      Each location implementation must provide the following methods:
+
+      * `getURL`: returns the current URL.
+      * `setURL(path)`: sets the current URL.
+      * `replaceURL(path)`: replace the current URL (optional).
+      * `onUpdateURL(callback)`: triggers the callback when the URL changes.
+      * `formatURL(url)`: formats `url` to be placed into `href` attribute.
+
+      Calling `setURL` or `replaceURL` will not trigger onUpdateURL callbacks.
+
+      ## Custom implementation
+
+      Ember scans `app/locations/*` for extending the Location API.
+
+      Example:
+
+      ```javascript
+      import HistoryLocation from '@ember/routing/history-location';
+
+      export default class MyHistory {
+        implementation = 'my-custom-history';
+
+        constructor() {
+          this._history = HistoryLocation.create(...arguments);
+        }
+
+        create() {
+          return new this(...arguments);
+        }
+
+        pushState(path) {
+           this._history.pushState(path);
+        }
+      }
+      ```
+
+      @for @ember/routing/location
+      @class Location
+      @since 5.0.0
+      @public
+    */
+    export default interface Location {
+        /**
+         * If the location needs to redirect to a different URL, it can cancel routing
+         * by setting the `cancelRouterSetup` property on itself to false.
+         * @property cancelRouterSetup
+         * @type Boolean
+         * @optional
+         * @default true
+         * @public
+         */
+        cancelRouterSetup?: boolean;
+        /**
+         * The current URL.
+         * @property currentURL
+         * @type String
+         * @public
+         */
+        getURL(): string;
+        /**
+         * Sets the current URL. Calling `setURL` will not trigger `onUpdateURL`
+         * callbacks.
+         *
+         * @property setURL
+         * @public
+         * @method
+         * @param {String} url the new URL to update to.
+         */
+        setURL(url: string): void;
+        /**
+         * Replace the current URL (optional). Calling `replaceURL` will not trigger
+         * `onUpdateURL` callbacks.
+         *
+         * @property replaceURL
+         * @public
+         * @method
+         * @param {String} url the new URL to replace the current URL with.
+         */
+        replaceURL?(url: string): void;
+        /**
+         * triggers the callback when the URL changes.
+         * @param {(newUrl: string) => void} callback A function to run when the URL
+         *   changes. The the new URL string is provided as the only argument.
+         */
+        onUpdateURL(callback: UpdateCallback): void;
+        /**
+         * Formats url to be placed into href attribute.
+         *
+         * @property formatURL
+         * @public
+         * @method
+         * @param {String} url the url to format
+         */
+        formatURL(url: string): string;
+        initState?(): void;
+        destroy(): void;
+    }
+    export type UpdateCallback = (url: string) => void;
+    export interface Registry extends Record<string, Location | undefined> {
+    }
+}

package/external-types/ember-source/types/stable/@ember/routing/none-location.d.ts

@@ -0,0 +1,79 @@
+declare module '@ember/routing/none-location' {
+    import EmberObject from "@ember/object";
+    import type { default as EmberLocation, UpdateCallback } from "@ember/routing/location";
+    /**
+    @module @ember/routing/none-location
+    */
+    /**
+      NoneLocation does not interact with the browser. It is useful for
+      testing, or when you need to manage state with your Router, but temporarily
+      don't want it to muck with the URL (for example when you embed your
+      application in a larger page).
+
+      Using `NoneLocation` causes Ember to not store the applications URL state
+      in the actual URL. This is generally used for testing purposes, and is one
+      of the changes made when calling `App.setupForTesting()`.
+
+      @class NoneLocation
+      @extends EmberObject
+      @protected
+    */
+    export default class NoneLocation extends EmberObject implements EmberLocation {
+        updateCallback?: UpdateCallback;
+        path: string;
+        /**
+          Will be pre-pended to path.
+      
+          @private
+          @property rootURL
+          @default '/'
+        */
+        rootURL: string;
+        initState(): void;
+        /**
+          Returns the current path without `rootURL`.
+      
+          @private
+          @method getURL
+          @return {String} path
+        */
+        getURL(): string;
+        /**
+          Set the path and remembers what was set. Using this method
+          to change the path will not invoke the `updateURL` callback.
+      
+          @private
+          @method setURL
+          @param path {String}
+        */
+        setURL(path: string): void;
+        /**
+          Register a callback to be invoked when the path changes. These
+          callbacks will execute when the user presses the back or forward
+          button, but not after `setURL` is invoked.
+      
+          @private
+          @method onUpdateURL
+          @param callback {Function}
+        */
+        onUpdateURL(callback: (url: string) => void): void;
+        /**
+          Sets the path and calls the `updateURL` callback.
+      
+          @private
+          @method handleURL
+          @param url {String}
+        */
+        handleURL(url: string): void;
+        /**
+          Given a URL, formats it to be placed into the page as part
+          of an element's `href` attribute.
+      
+          @private
+          @method formatURL
+          @param {String} url
+          @return {String} url
+        */
+        formatURL(url: string): string;
+    }
+}

package/external-types/ember-source/types/stable/@ember/routing/owner-ext.d.ts

@@ -0,0 +1,11 @@
+// This module provides an 'extension' to the `@ember/owner` module from the
+// `@ember/routing/location` module. Our type publishing infrastructure will
+// pass it through unchanged, so end users will get this extension.
+
+import type { Registry } from '@ember/routing/location';
+
+declare module '@ember/owner' {
+  export interface DIRegistry {
+    location: Registry;
+  }
+}

package/external-types/ember-source/types/stable/@ember/routing/route-info.d.ts

@@ -0,0 +1,125 @@
+declare module '@ember/routing/route-info' {
+    /**
+      Re-exports the `RouteInfo` and `RouteInfoWithMetadata` types from [router.js].
+      `RouteInfo` and `RouteInfoWithMetadata` appear as properties on `Transition`
+      instances.
+
+      [router.js]: https://github.com/tildeio/router.js
+
+      @module @ember/routing/route-info
+     */
+    /**
+      A `RouteInfo` is an object that contains metadata about a specific route
+      within a `Transition`. It is read-only and internally immutable. It is also
+      not observable, because a `Transition` instance is never changed after
+      creation.
+
+      A `RouteInfo` is not user-constructible; the only legal way to get one is from
+      a valid `Transition`. However, you can import the type by using `import type`
+      syntax with TypeScript or `import()` in JSDoc comments.
+
+      @class RouteInfo
+      @public
+     */
+    /**
+      The dot-separated, fully-qualified name of the route, like `"people.index"`.
+      @property {String} name
+      @public
+     */
+    /**
+      The final segment of the fully-qualified name of the route, like `"index"`
+      @property {String} localName
+      @public
+     */
+    /**
+      The values of the route's parameters. These are the same params that are
+      received as arguments to the route's `model` hook. Contains only the
+      parameters valid for this route, if any (params for parent or child routes are
+      not merged).
+      @property {Object} params
+      @public
+     */
+    /**
+      The ordered list of the names of the params required for this route. It will
+      contain the same strings as Object.keys(params), but here the order is
+      significant. This allows users to correctly pass params into routes
+      programmatically.
+      @property {Array} paramNames
+      @public
+     */
+    /**
+      The values of any queryParams on this route.
+      @property {Object} queryParams
+      @public
+     */
+    /**
+      Will contain the result `Route#buildRouteInfoMetadata` for the corresponding
+      Route.
+      @property {Any} metadata
+      @public
+     */
+    /**
+      A reference to the parent route's `RouteInfo`. This can be used to traverse
+      upward to the topmost `RouteInfo`.
+      @property {RouteInfo|null} parent
+      @public
+     */
+    /**
+      A reference to the child route's `RouteInfo`. This can be used to traverse
+      downward to the leafmost `RouteInfo`.
+      @property {RouteInfo|null} child
+      @public
+     */
+    /**
+      Allows you to traverse through the linked list of `RouteInfo`s from the
+      topmost to leafmost. Returns the first `RouteInfo` in the linked list for
+      which the callback returns true.
+
+      This method is similar to the `find()` method defined in ECMAScript 2015.
+
+      The callback method you provide should have the following signature (all
+      parameters are optional):
+
+      ```javascript
+      function(item, index, array);
+      ```
+
+      - `item` is the current item in the iteration.
+      - `index` is the current index in the iteration.
+      - `array` is the array itself.
+
+      It should return the `true` to include the item in the results, `false`
+      otherwise.
+
+      Note that in addition to a callback, you can also pass an optional target
+      object that will be set as `this` on the context.
+
+      @method find
+      @param {Function} callback the callback to execute
+      @param {Object} [target*] optional target to use
+      @returns {Object} Found item or undefined
+      @public
+     */
+    /**
+      A `RouteInfoWithAttributes` is an object that contains metadata, including the
+      resolved value from the routes `model` hook. Like `RouteInfo`, a
+      `RouteInfoWithAttributes` represents a specific route within a Transition. It
+      is read-only and internally immutable. It is also not observable, because a
+      Transition instance is never changed after creation.
+
+      A `RouteInfoWithAttributes` is not user-constructible; the only legal way to
+      get one is from a valid `Transition`. However, you can import the type by
+      using `import type` syntax with TypeScript or `import()` in JSDoc comments.
+
+      @class RouteInfoWithAttributes
+      @extends RouteInfo
+      @public
+     */
+    /**
+       This is the resolved return value from the
+       route's model hook.
+       @property {Object|Array|String|undefined} attributes
+       @public
+     */
+    export type { RouteInfo as default, RouteInfoWithAttributes } from "@ember/routing/lib/route-info";
+}