@spinnaker/core 0.0.0-2025.1-0

package/LICENSE.txt

@@ -0,0 +1,203 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright 2014 Netflix
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+   

package/codegen.yml

@@ -0,0 +1,18 @@
+overwrite: true
+schema:
+  - src/managed/graphql/schema.graphql # TODO: move this file to a separate node module
+documents: src/**/*.graphql
+generates:
+  src/managed/graphql/graphql-sdk.ts:
+    plugins:
+      - add:
+          content: '/* eslint-disable @typescript-eslint/array-type */'
+      - typescript
+      - typescript-operations
+      - typescript-react-apollo
+    config:
+      declarationKind: 'interface'
+      enumsAsTypes: true
+      maybeValue: T | undefined
+      scalars:
+        InstantTime: string

package/dist/account/AccountSelectInput.d.ts

@@ -0,0 +1,24 @@
+import React from 'react';
+import type { IAccount } from './AccountService';
+import type { IFormInputProps } from '../presentation/forms/inputs';
+export interface IAccountSelectInputProps extends IFormInputProps {
+    accounts: IAccount[] | string[];
+    provider: string;
+    readOnly?: boolean;
+    renderFilterableSelectThreshold?: number;
+}
+export interface IAccountSelectInputState {
+    mergedAccounts: string[];
+    primaryAccounts: string[];
+    secondaryAccounts: string[];
+}
+export declare class AccountSelectInput extends React.Component<IAccountSelectInputProps, IAccountSelectInputState> {
+    static defaultProps: {
+        renderFilterableSelectThreshold: number;
+    };
+    state: IAccountSelectInputState;
+    private groupAccounts;
+    componentDidMount(): void;
+    componentWillReceiveProps(nextProps: IAccountSelectInputProps): void;
+    render(): JSX.Element;
+}

package/dist/account/AccountService.d.ts

@@ -0,0 +1,68 @@
+import type { Observable } from 'rxjs';
+import type { Application } from '../application/application.model';
+export interface IRegion {
+    account?: string;
+    availabilityZones?: string[];
+    deprecated?: boolean;
+    endpoint?: string;
+    faultDomains?: string[];
+    name: string;
+    preferredZones?: string[];
+}
+export interface IAccount {
+    accountId: string;
+    name: string;
+    requiredGroupMembership: string[];
+    type: string;
+}
+export interface IArtifactAccount {
+    name: string;
+    types: string[];
+}
+export interface IAccountDetails extends IAccount {
+    accountType: string;
+    authorized: boolean;
+    awsAccount?: string;
+    awsVpc?: string;
+    bastionHost?: string;
+    challengeDestructiveActions: boolean;
+    cloudProvider: string;
+    defaultKeyPair?: string;
+    environment: string;
+    primaryAccount: boolean;
+    regions: IRegion[];
+    registry?: string;
+    namespaces?: string[];
+    spinnakerKindMap?: {
+        [k: string]: string;
+    };
+}
+export interface IAggregatedAccounts {
+    [credentials: string]: IAccountDetails;
+}
+export interface IZone {
+    [key: string]: string[];
+}
+export interface IAccountZone {
+    [key: string]: IZone;
+}
+export declare class AccountService {
+    static accounts$: Observable<IAccountDetails[]>;
+    static providers$: Observable<string[]>;
+    static initialize(): void;
+    static challengeDestructiveActions(account: string): PromiseLike<boolean>;
+    static getArtifactAccounts(): PromiseLike<IArtifactAccount[]>;
+    static getAccountDetails(account: string): PromiseLike<IAccountDetails>;
+    static getAllAccountDetailsForProvider(provider: string): PromiseLike<IAccountDetails[]>;
+    static getAvailabilityZonesForAccountAndRegion(provider: string, account: string, region: string): PromiseLike<string[]>;
+    static getCredentialsKeyedByAccount(provider?: string): PromiseLike<IAggregatedAccounts>;
+    static getPreferredZonesByAccount(provider: string): PromiseLike<IAccountZone>;
+    static getRegionsForAccount(account: string): PromiseLike<IRegion[]>;
+    static getUniqueAttributeForAllAccounts(provider: string, attribute: string): PromiseLike<string[]>;
+    static listAllAccounts(provider?: string): PromiseLike<IAccountDetails[]>;
+    static listAccounts(provider?: string): PromiseLike<IAccountDetails[]>;
+    static applicationAccounts(application?: Application): PromiseLike<IAccountDetails[]>;
+    static listProviders$(application?: Application): Observable<string[]>;
+    static listProviders(application?: Application): PromiseLike<string[]>;
+    static getAccountForInstance(cloudProvider: string, instanceId: string, app: Application): PromiseLike<string>;
+}

package/dist/account/AccountTag.d.ts

@@ -0,0 +1,20 @@
+import React from 'react';
+export interface IAccountTagProps {
+    account: string;
+    className?: string;
+}
+export interface IAccountTagState {
+    isProdAccount: boolean;
+}
+export declare class AccountTag extends React.Component<IAccountTagProps, IAccountTagState> {
+    private static cache;
+    state: {
+        isProdAccount: boolean;
+    };
+    private mounted;
+    componentWillUnmount(): void;
+    componentDidMount(): void;
+    componentWillReceiveProps(nextProps: IAccountTagProps): void;
+    private updateAccount;
+    render(): JSX.Element;
+}

package/dist/account/account.module.d.ts

@@ -0,0 +1,2 @@
+export const CORE_ACCOUNT_ACCOUNT_MODULE: "spinnaker.core.account";
+export const name: "spinnaker.core.account";

package/dist/account/accountSelect.wrapper.d.ts

@@ -0,0 +1 @@
+export declare const ACCOUNT_SELECT_WRAPPER = "spinnaker.core.account.select.wrapper";

package/dist/account/accountSelectField.component.d.ts

@@ -0,0 +1 @@
+export declare const ACCOUNT_SELECT_COMPONENT = "spinnaker.core.account.accountSelectField.component";

package/dist/account/accountTag.component.d.ts

@@ -0,0 +1,4 @@
+import type { IComponentOptions } from 'angular';
+import './accountTag.less';
+export declare const accountTagComponent: IComponentOptions;
+export declare const ACCOUNT_TAG_COMPONENT = "spinnaker.core.account.accountTag";

package/dist/account/collapsibleAccountTag.directive.d.ts

@@ -0,0 +1,2 @@
+export const CORE_ACCOUNT_COLLAPSIBLEACCOUNTTAG_DIRECTIVE: "spinnaker.core.account.collapsibleAccountTag.directive";
+export const name: "spinnaker.core.account.collapsibleAccountTag.directive";

package/dist/account/index.d.ts

@@ -0,0 +1,3 @@
+export * from './AccountSelectInput';
+export * from './AccountService';
+export * from './AccountTag';

package/dist/account/providerToggles.directive.d.ts

@@ -0,0 +1,2 @@
+export const CORE_ACCOUNT_PROVIDERTOGGLES_DIRECTIVE: "spinnaker.core.account.providerToggle.directive";
+export const name: "spinnaker.core.account.providerToggle.directive";

package/dist/analytics/GoogleAnalyticsInitializer.d.ts

@@ -0,0 +1,2 @@
+import 'angulartics';
+import 'angulartics-google-analytics';

package/dist/analytics/angulartics.module.d.ts

@@ -0,0 +1,2 @@
+/// <reference path="../../src/analytics/angulartics.module.d.ts" />
+export declare const ANALYTICS_MODULE = "spinnaker.core.analytics";

package/dist/api/ApiService.d.ts

@@ -0,0 +1,133 @@
+import type { ICache } from '../cache/deckCacheFactory';
+type IPrimitive = string | boolean | number;
+type IParams = Record<string, IPrimitive | IPrimitive[]>;
+interface Headers {
+    [headerName: string]: string;
+}
+/**
+ * A Builder API for making requests to Gate backend service
+ */
+export interface IRequestBuilder {
+    /**
+     * Appends one or more path segments to the URL, separated by slashes.
+     * Each path segment is uri encoded.
+     */
+    path(...pathSegments: IPrimitive[]): this;
+    headers(headers: Headers): this;
+    /** Adds query parameters to the URL */
+    query(queryParams: IParams): this;
+    /** Enables or disables caching of the response */
+    useCache(useCache?: boolean): this;
+    /** issues a GET request */
+    get<T = any>(): PromiseLike<T>;
+    /** issues a POST request */
+    post<T = any, P = any>(data?: P): PromiseLike<T>;
+    /** issues a PUT request */
+    put<T = any, P = any>(data?: P): PromiseLike<T>;
+    /** issues a PATCH request */
+    patch<T = any, P = any>(data?: P): PromiseLike<T>;
+    /** issues a DELETE request */
+    delete<T = any, P = any>(data?: P): PromiseLike<T>;
+}
+/**
+ * Internal interface to encapsulate a request
+ * Passed to the IHttpClientImplementation
+ */
+interface IRequestBuilderConfig {
+    url: string;
+    timeout?: number;
+    headers?: Headers;
+    /** @deprecated used for AngularJS backwards compat */
+    data?: any;
+    params?: object;
+    cache?: boolean;
+}
+/**
+ * The old API interface
+ */
+export interface IDeprecatedRequestBuilder extends IRequestBuilder {
+    useCache(): this;
+    useCache(useCache: boolean): this;
+    useCache(useCache: ICache): this;
+    withParams(queryParams: IParams): this;
+    /** @deprecated do not use this config object */
+    config: IRequestBuilderConfig;
+    /** @deprecated use SETTINGS.gateUrl */
+    baseUrl: string;
+    /** @deprecated use path() instead (this is a passthrough to path) */
+    one(...urls: string[]): this;
+    /** @deprecated use one() instead (this is a passthrough to one) */
+    all(...urls: string[]): this;
+    /** @deprecated use put(data) or post(data) instead */
+    data(data: any): this;
+    get<T = any>(params?: IParams): PromiseLike<T>;
+    /** @deprecated use delete() instead (this is a passthrough to delete) */
+    remove(params?: IParams): PromiseLike<any>;
+    /** @deprecated use get() instead (this is a passthrough to get) */
+    getList<T = any>(params?: IParams): PromiseLike<T>;
+}
+/**
+ * An interface to support pluggable http clients
+ * In the future, we should have a TestingHttpClient and a FetchHttpClient (or whatever http client we go with)
+ */
+export interface IHttpClientImplementation {
+    get<T = any>(config: IRequestBuilderConfig): PromiseLike<T>;
+    post<T = any>(config: IRequestBuilderConfig): PromiseLike<T>;
+    put<T = any>(config: IRequestBuilderConfig): PromiseLike<T>;
+    patch<T = any>(config: IRequestBuilderConfig): PromiseLike<T>;
+    delete<T = any>(config: IRequestBuilderConfig): PromiseLike<T>;
+}
+export declare class InvalidAPIResponse extends Error {
+    originalResult: any;
+    data: {
+        message: string;
+    };
+    constructor(message: string, originalResult: any);
+}
+/** The base request builder implementation */
+export declare class RequestBuilder implements IRequestBuilder {
+    protected config: IRequestBuilderConfig;
+    protected _httpClient?: IHttpClientImplementation;
+    protected _baseUrl?: string;
+    static defaultHttpClient: IHttpClientImplementation;
+    constructor(config?: IRequestBuilderConfig, _httpClient?: IHttpClientImplementation, _baseUrl?: string);
+    protected builder(newRequest: IRequestBuilderConfig): this;
+    protected get httpClient(): IHttpClientImplementation;
+    protected get baseUrl(): string;
+    path(...paths: IPrimitive[]): this;
+    headers(headers: Headers): this;
+    get<T>(queryParams?: object): PromiseLike<T>;
+    post<T>(postData?: any): PromiseLike<T>;
+    put<T>(putData?: any): PromiseLike<T>;
+    patch<T>(putData?: any): PromiseLike<T>;
+    delete<T>(deleteData?: any): PromiseLike<T>;
+    useCache(cache?: boolean): this;
+    query(queryParams: IParams): this;
+}
+/**
+ * This class extends RequestBuilder and re-implements the deprecated API for backwards compat
+ * @deprecated
+ */
+export declare class DeprecatedRequestBuilder extends RequestBuilder implements IDeprecatedRequestBuilder {
+    protected builder: (newRequest: IRequestBuilderConfig) => this;
+    config: IRequestBuilderConfig;
+    get baseUrl(): string;
+    getList: any;
+    one: any;
+    all: any;
+    remove: any;
+    data: (data: any) => this;
+    withParams: any;
+    useCache: (cache?: boolean | ICache) => this;
+}
+export declare const invalidContentMessage = "API response was neither JSON nor zero-length html or text";
+export declare function makeRequestBuilderConfig(pathPrefix?: string): IRequestBuilderConfig;
+/** @deprecated use REST('/path/to/gate/endpoint') */
+export declare const API: IDeprecatedRequestBuilder;
+/**
+ * A REST client used to access Gate endpoints
+ * @param staticPathPrefix a static string, i.e., '/proxies/foo/endpoint' --
+ *        avoid dynamic strings like `/entity/${id}`, use .path('entity', id) instead
+ */
+export declare const REST: (staticPathPrefix?: string) => IRequestBuilder;
+export {};

package/dist/api/index.d.ts

@@ -0,0 +1 @@
+export * from './ApiService';

package/dist/api/mock/expectedRequest.d.ts

@@ -0,0 +1,68 @@
+import type { UrlArg, Verb } from './mockHttpUtils';
+import type { ReceivedRequest } from './receivedRequest';
+/**
+ * This class represents an HTTP request that is expected to be made by the code under test.
+ * Instances are created by MockHttpClient.expect -- this class should not be used directly.
+ *
+ * This class exposes a promise (this.fulfilledDeferred.promise).
+ * The promise will be resolved when the code under test makes the expected HTTP request.
+ *
+ * ExpectedRequest also stores the (optional) mock response status/data to return to the code under test.
+ */
+export declare class ExpectedRequest implements IExpectBuilder {
+    verb: Verb;
+    urlArg: UrlArg;
+    path: string;
+    expectedParams: {};
+    exactParams: boolean;
+    onResponseReceivedCallback: (request: ReceivedRequest) => void;
+    /**
+     * Creates a new ExpectRequest object
+     * @param verb GET/PUT/POST/DELETE
+     * @param urlArg the URL to match: string, regexp, or matcher
+     *            If a string, query params are parsed out of the string and used as a partial match against each request
+     *            e.g.: '/foo/bar?param1=val1&param2=val2'
+     */
+    constructor(verb: Verb, urlArg?: UrlArg);
+    response: {
+        status: number;
+        data: any;
+    };
+    isFulfilled: () => boolean;
+    fulfilledDeferred: import("./mockHttpUtils").IDeferred;
+    /**
+     * Marks the expected response as fulfilled and settles the promise using the mock response.
+     */
+    fulfill(): void;
+    isMatchAndUnfulfilled(verb: Verb, url: string, params: object): boolean;
+    matchVerb: (verb: Verb) => boolean;
+    matchUrl: (requestUrl: string) => boolean;
+    matchParams: (requestParams: object) => boolean;
+    onRequestReceived(callback: (request: ReceivedRequest) => void): this;
+    withParams(expectedParams: {}, exact?: boolean): IExpectBuilder;
+    respond(status: number, data?: any): IExpectBuilder;
+}
+export interface IExpectBuilder {
+    /**
+     * This callback is invoked when the expected request is received
+     * @param callback The callback to invoke.
+     *        The callback receives the ReceivedRequest object
+     */
+    onRequestReceived(callback: (request: ReceivedRequest) => void): IExpectBuilder;
+    /**
+     * Match only requests with the expected query parameters
+     * @param expectedParams the required params to match
+     * @param exact match exact params
+     *        false: (default) actual params must include expected params
+     *        true: actual params exactly match expected params
+     */
+    withParams(expectedParams: {}, exact?: boolean): IExpectBuilder;
+    /**
+     * Set the response for the expected request
+     * @param status the HTTP status code
+     *        - For 2xx status codes, resolves the promise.
+     *        - For other status codes, rejects the promise
+     * @param data the response payload
+     */
+    respond(status: number, data?: any): IExpectBuilder;
+}

package/dist/api/mock/jasmine.d.ts

@@ -0,0 +1,7 @@
+import { MockHttpClient } from './mockHttpClient';
+export interface IMockHttpClientConfig {
+    autoFlush?: boolean;
+    failOnUnexpectedRequests?: boolean;
+}
+export declare function mockHttpClient(config?: IMockHttpClientConfig): MockHttpClient;
+export declare function jasmineMockHttpSupport(): void;

package/dist/api/mock/mockHttpClient.d.ts

@@ -0,0 +1,68 @@
+import type { IHttpClientImplementation } from '../ApiService';
+import type { IExpectBuilder } from './expectedRequest';
+import { ExpectedRequest } from './expectedRequest';
+import type { IDeferred, UrlArg, Verb } from './mockHttpUtils';
+import { ReceivedRequest } from './receivedRequest';
+interface IRequest {
+    verb: Verb;
+    url: string;
+    params: object;
+    data: any;
+    expected: boolean;
+    responseDeferred: IDeferred;
+    flushResponse: () => void;
+}
+/**
+ * A mock HTTP client for unit tests.
+ *
+ * This class (and its counterparts) enables unit tests to expect that the code
+ * being tested makes certain HTTP calls.  When the code makes the expected HTTP
+ * calls, the responses are deferred until the unit test calls .flush().  Then,
+ * any pending responses are flushed.
+ */
+export declare class MockHttpClient implements IHttpClientImplementation {
+    autoFlush: boolean;
+    failOnUnexpectedRequests: boolean;
+    expectedRequests: ExpectedRequest[];
+    receivedRequests: ReceivedRequest[];
+    private isFlushing;
+    expect(verb: Verb, url?: UrlArg): IExpectBuilder;
+    expectGET: (url?: UrlArg) => IExpectBuilder;
+    expectPUT: (url?: UrlArg) => IExpectBuilder;
+    expectPOST: (url?: UrlArg) => IExpectBuilder;
+    expectDELETE: (url?: UrlArg) => IExpectBuilder;
+    expectPATCH: (url?: UrlArg) => IExpectBuilder;
+    request<T = any>(verb: Verb, iRequest: IRequest): PromiseLike<T>;
+    get: <T = any>(request: IRequest) => PromiseLike<T>;
+    put: <T = any>(request: IRequest) => PromiseLike<T>;
+    post: <T = any>(request: IRequest) => PromiseLike<T>;
+    patch: <T = any>(request: IRequest) => PromiseLike<T>;
+    delete: <T = any>(request: IRequest) => PromiseLike<T>;
+    private requestListeners;
+    private addRequestListener;
+    private needsFlush;
+    /**
+     * Waits until all expected requests are received.
+     * This function is async and should be await'ed in the unit test.
+     *
+     * 1) Flushes the response data for all received requests.
+     *    The Promises in the code being tested will resolve or reject.
+     * 2) Resolves when all expected requests have been fulfilled by a received request.
+     *
+     * If more requests are received during the wait period, they are also flushed.
+     *
+     * For interop with AngularJS code, the $httpBackend is also flushed
+     *
+     * @param timeoutMs: How long to wait for all the expected requests to be received. (default: 100)
+     * @param delayAfterMs: How long to wait AFTER all the expected requests have been received (default: 0)
+     */
+    flush({ timeoutMs, delayAfterMs }?: {
+        timeoutMs?: number;
+        delayAfterMs?: number;
+    }): Promise<void>;
+    private getOutstandingExpectationMessages;
+    verifyNoOutstandingExpectation(): void;
+    verifyNoOutstandingRequests(): void;
+    verifyNoUnexpectedRequests(): void;
+}
+export {};