@spinnaker/core 0.0.0-main-2

package/dist/function/filter/FunctionFilters.d.ts

@@ -0,0 +1,27 @@
+import React from 'react';
+import type { Application } from '../../application';
+import type { ISortFilter } from '../../filterModel';
+export interface IFunctionFiltersProps {
+    app: Application;
+}
+export interface IFunctionFiltersState {
+    sortFilter: ISortFilter;
+    tags: any[];
+    providerTypeHeadings: string[];
+    accountHeadings: string[];
+    regionHeadings: string[];
+}
+export declare class FunctionFilters extends React.Component<IFunctionFiltersProps, IFunctionFiltersState> {
+    private debouncedUpdateFunctionGroups;
+    private groupsUpdatedSubscription;
+    private functionsRefreshUnsubscribe;
+    private locationChangeUnsubscribe;
+    constructor(props: IFunctionFiltersProps);
+    componentDidMount(): void;
+    componentWillUnmount(): void;
+    updateFunctionGroups: (applyParamsToUrl?: boolean) => void;
+    private getHeadingsForOption;
+    private handleSearchBlur;
+    private handleSearchChange;
+    render(): JSX.Element;
+}

package/dist/function/function.dataSource.d.ts

@@ -0,0 +1 @@
+export declare const FUNCTION_DATA_SOURCE = "spinnaker.core.functions.dataSource";

package/dist/function/function.module.d.ts

@@ -0,0 +1 @@
+export declare const FUNCTION_MODULE = "spinnaker.core.function";

package/dist/function/function.read.service.d.ts

@@ -0,0 +1,22 @@
+import type { IFunctionSourceData } from '../domain';
+import type { IFunctionTransformer } from './function.transformer';
+export interface IFunctionByAccount {
+    name: string;
+    accounts: Array<{
+        name: string;
+        regions: Array<{
+            name: string;
+            functions: IFunctionSourceData[];
+        }>;
+    }>;
+}
+export declare class FunctionReader {
+    private functionTransformer;
+    static $inject: string[];
+    constructor(functionTransformer: IFunctionTransformer);
+    loadFunctions(applicationName: string): PromiseLike<IFunctionSourceData[]>;
+    getFunctionDetails(cloudProvider: string, account: string, region: string, name: string): PromiseLike<IFunctionSourceData[]>;
+    listFunctions(cloudProvider: string): PromiseLike<IFunctionByAccount[]>;
+    private normalizeFunction;
+}
+export declare const FUNCTION_READ_SERVICE = "spinnaker.core.function.read.service";

package/dist/function/function.states.d.ts

@@ -0,0 +1 @@
+export declare const FUNCTION_STATES = "spinnaker.core.functions.states";

package/dist/function/function.transformer.d.ts

@@ -0,0 +1,7 @@
+import type { IFunctionSourceData } from '../index';
+export declare const CORE_FUNCTION_FUNCTION_TRANSFORMER = "spinnaker.core.function.transformer";
+export declare const name = "spinnaker.core.function.transformer";
+export interface IFunctionTransformer {
+    normalizeFunction: (functionDef: IFunctionSourceData) => IFunctionSourceData;
+    normalizeFunctionSet: (functions: IFunctionSourceData[]) => IFunctionSourceData[];
+}

package/dist/function/function.write.service.d.ts

@@ -0,0 +1,23 @@
+import type { Application } from '../application/application.model';
+import type { ITask } from '../domain';
+import type { IJob } from '../task/taskExecutor';
+export interface IFunctionUpsertCommand extends IJob {
+    functionName: string;
+    cloudProvider: string;
+    credentials: string;
+    description?: string;
+    region: string;
+    operation: string;
+}
+export interface IFunctionDeleteCommand extends IJob {
+    cloudProvider: string;
+    functionName: string;
+    credentials: string;
+    region: string;
+    vpcId?: string;
+    operation?: string;
+}
+export declare class FunctionWriter {
+    static deleteFunction(command: IFunctionDeleteCommand, application: Application): PromiseLike<ITask>;
+    static upsertFunction(command: IFunctionUpsertCommand, application: Application, descriptor: string, params?: any): PromiseLike<ITask>;
+}

package/dist/function/index.d.ts

@@ -0,0 +1,4 @@
+export * from './FunctionDetails';
+export * from './function.read.service';
+export * from './function.write.service';
+export * from './CreateFunctionButton';

package/dist/header/SpinnakerHeader.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="react" />
+import './SpinnakerHeader.css';
+export declare const SpinnakerHeaderContent: () => JSX.Element;
+export declare const SpinnakerHeader: () => JSX.Element;

package/dist/header/customBanner/CustomBanner.d.ts

@@ -0,0 +1,16 @@
+import React from 'react';
+import type { ICustomBannerConfig } from '../../application/config/customBanner/CustomBannerConfig';
+import './CustomBanner.less';
+export interface ICustomBannerState {
+    applicationName: string;
+    bannerConfig: ICustomBannerConfig;
+}
+export declare class CustomBanner extends React.Component<{}, ICustomBannerState> {
+    private locationChangeUnsubscribe;
+    state: ICustomBannerState;
+    componentDidMount(): void;
+    private updateApplication;
+    updateBannerConfig(attributes: any): void;
+    render(): React.ReactElement<CustomBanner>;
+    componentWillUnmount(): void;
+}

package/dist/healthCounts/HealthCounts.d.ts

@@ -0,0 +1,22 @@
+import React from 'react';
+import type { IInstanceCounts } from '../domain';
+import type { Placement } from '../presentation';
+import './healthCounts.less';
+export interface IHealthCountsProps {
+    className?: string;
+    container: IInstanceCounts;
+    additionalLegendText?: string;
+    legendPlacement?: Placement;
+}
+export interface IHealthCountsState {
+    percentLabel: string;
+    statusClass: string;
+    total: number;
+}
+export declare class HealthCounts extends React.Component<IHealthCountsProps, IHealthCountsState> {
+    static defaultProps: Partial<IHealthCountsProps>;
+    constructor(props: IHealthCountsProps);
+    private calculatePercent;
+    componentWillReceiveProps(nextProps: IHealthCountsProps): void;
+    render(): React.ReactElement<HealthCounts>;
+}

package/dist/healthCounts/healthCounts.component.d.ts

@@ -0,0 +1 @@
+export declare const HEALTH_COUNTS_COMPONENT = "spinnaker.core.healthCounts.component";

package/dist/healthCounts/healthCounts.module.d.ts

@@ -0,0 +1 @@
+export declare const HEALTH_COUNTS_MODULE = "spinnaker.core.healthCounts";

package/dist/healthCounts/index.d.ts

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

package/dist/helm-chart-artifact2320ab55b431ba0a.svg

@@ -0,0 +1,14 @@
+<svg id="Layer_1" data-name="Layer 1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink"
+     viewBox="0 0 124 129.12">
+  <defs>
+    <style>.cls-1{isolation:isolate;}</style>
+  </defs>
+  <title>helm-logo</title>
+  <g id="Page-1">
+    <g id="Group-4">
+      <image id="helm_logo_transparent" data-name="helm logo transparent" class="cls-1" width="605" height="630"
+             transform="scale(0.2)"
+             xlink:href="data:image/svg+xml;base64,<svg data-name="Layer 1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" viewBox="0 0 124 129.12"><image data-name="helm logo transparent" width="605" height="630" transform="scale(.2)" xlink:href="data:image/png;base64,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" style="isolation:isolate"/></svg>"/>
+    </g>
+  </g>
+</svg>

package/dist/help/HelpField.d.ts

@@ -0,0 +1,11 @@
+/// <reference types="react" />
+import type { Placement } from '../presentation/Placement';
+export interface IHelpFieldProps {
+    id?: string;
+    fallback?: string;
+    content?: string;
+    placement?: Placement;
+    expand?: boolean;
+    label?: string;
+}
+export declare function HelpField(props: IHelpFieldProps): JSX.Element;

package/dist/help/HelpMenu.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="react" />
+import './HelpMenu.less';
+export declare const HelpMenu: () => JSX.Element;

package/dist/help/HelpTextExpandedContext.d.ts

@@ -0,0 +1,2 @@
+import React from 'react';
+export declare const HelpTextExpandedContext: React.Context<boolean>;

package/dist/help/help.contents.d.ts

@@ -0,0 +1,3 @@
+export interface IHelpContents {
+    [key: string]: string;
+}

package/dist/help/help.module.d.ts

@@ -0,0 +1,2 @@
+import './help.contents';
+export declare const HELP_MODULE = "spinnaker.core.help";

package/dist/help/helpContents.registry.d.ts

@@ -0,0 +1,25 @@
+export declare class HelpContentsRegistry {
+    private static helpFields;
+    private static overrides;
+    /**
+     * Returns the configured help value, or null if nothing is configured
+     * @param key the key
+     * @returns the configured help value, or null
+     */
+    static getHelpField(key: string): string;
+    /**
+     * Adds a help field to the registry. This value can be overridden by calling #registerOverride
+     * If an override has been configured, this call will *not* change the already-configured value
+     * @param key the key
+     * @param val the value
+     */
+    static register(key: string, val: string): void;
+    /**
+     * Adds a help field to the registry and locks it, preventing subsequent registrations with the same key from
+     * replacing its value. Subsequent calls to this method with the same key will have no effect on the value.
+     *
+     * @param key the key
+     * @param val the value
+     */
+    static registerOverride(key: string, val: string): void;
+}

package/dist/help/helpField.component.d.ts

@@ -0,0 +1,14 @@
+import type { IComponentOptions, IController } from 'angular';
+export declare class HelpFieldCtrl implements IController {
+    content: string;
+    expand: boolean;
+    fallback: string;
+    key: string;
+    label: string;
+    placement: string;
+}
+/**
+ * The only purpose of this is to map `key` to `id` so the React version of `HelpField` can be leveraged.
+ */
+export declare const helpFieldComponent: IComponentOptions;
+export declare const HELP_FIELD_COMPONENT = "spinnaker.core.help.helpField.component";

package/dist/help/helpFieldReact.component.d.ts

@@ -0,0 +1 @@
+export declare const HELP_FIELD_REACT_COMPONENT = "spinnaker.core.help.helpFieldReact.component";

package/dist/help/index.d.ts

@@ -0,0 +1,5 @@
+export * from './HelpField';
+export * from './HelpMenu';
+export * from './HelpTextExpandedContext';
+export * from './help.contents';
+export * from './helpContents.registry';

package/dist/history/index.d.ts

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

package/dist/history/recentHistory.service.d.ts

@@ -0,0 +1,33 @@
+export interface ICacheEntryStateMigrator {
+    state: string;
+    replacement: string;
+}
+export interface IRecentHistoryEntry {
+    params: any;
+    state: string;
+    accessTime: number;
+    extraData: any;
+    id: string;
+}
+export declare class RecentHistoryService {
+    private static cache;
+    static getItems(type: any): IRecentHistoryEntry[];
+    static addItem(type: string, state: string, params: any, keyParams?: string[]): void;
+    static removeItem(type: string, id: string): void;
+    static removeLastItem(type: string): void;
+    /**
+     * Used to include additional fields needed by display formatters that might not be present in $stateParams,
+     * but are resolved in a controller when the view loads
+     * See instanceDetails.controller.js for an example
+     * @param type
+     * @param extraData
+     */
+    static addExtraDataToLatest(type: string, extraData: any): void;
+    /**
+     * Called when deleting an application to remove its record in recent history
+     * @param appName
+     */
+    static removeByAppName(appName: string): void;
+    private static getExisting;
+}
+export declare const RECENT_HISTORY_SERVICE = "spinnaker.core.history.recentHistory.service";

package/dist/image/image.reader.d.ts

@@ -0,0 +1,28 @@
+import type { ProviderServiceDelegate } from '../cloudProvider/providerService.delegate';
+export declare type IFindImageParams = {
+    provider: string;
+    q?: string;
+    region?: string;
+    account?: string;
+    count?: number;
+};
+export declare type IFindTagsParams = {
+    provider: string;
+    account: string;
+    repository: string;
+};
+export interface IImage {
+}
+export interface IImageReader {
+    findImages(params: IFindImageParams): PromiseLike<IImage[]>;
+    getImage(imageName: string, region: string, credentials: string): PromiseLike<IImage>;
+}
+export declare class ImageReader {
+    private providerServiceDelegate;
+    static $inject: string[];
+    constructor(providerServiceDelegate: ProviderServiceDelegate);
+    private getDelegate;
+    findImages(params: IFindImageParams): PromiseLike<IImage[]>;
+    getImage(cloudProvider: string, imageName: string, region: string, credentials: string): PromiseLike<IImage>;
+}
+export declare const IMAGE_READER = "spinnaker.core.image.reader";

package/dist/image/index.d.ts

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

package/dist/index.d.ts

@@ -0,0 +1,69 @@
+/// <reference path="../src/types/index.d.ts" />
+import './utils/failedToInstantiateModule';
+export * from './account';
+export * from './api';
+export * from './application';
+export * from './artifact';
+export * from './authentication';
+export * from './banner';
+export * from './cache';
+export * from './certificates';
+export * from './ci';
+export * from './cloudProvider';
+export * from './cluster';
+export * from './config';
+export * from './confirmationModal';
+export * from './deploymentStrategy';
+export * from './domain';
+export * from './entityTag';
+export * from './pipeline/config/stages/common/ExecutionMarkerIcon';
+export * from './entityTag/notifications/EntityNotifications';
+export * from './artifact';
+export * from './diffs';
+export * from './event/EventBus';
+export * from './filterModel';
+export * from './forms';
+export * from './healthCounts';
+export * from './help';
+export * from './help/HelpField';
+export * from './history';
+export * from './image';
+export * from './instance';
+export * from './loadBalancer';
+export * from './function';
+export * from './modal';
+export * from './managed';
+export * from './manifest';
+export * from './naming';
+export * from './navigation';
+export * from './network';
+export * from './notification';
+export * from './orchestratedItem';
+export * from './overrideRegistry';
+export * from './pageTitle';
+export * from './pagerDuty';
+export * from './pipeline';
+export * from './plugins';
+export * from './presentation';
+export * from './projects';
+export * from './pubsub';
+export * from './reactShims';
+export * from './region';
+export * from './registry';
+export * from './retry';
+export * from './scheduler';
+export * from './search';
+export * from './securityGroup';
+export * from './serverGroup';
+export * from './serverGroupManager';
+export * from './serviceAccount';
+export * from './services';
+export * from './slack';
+export * from './state';
+export * from './storage';
+export * from './subnet';
+export * from './task';
+export * from './utils';
+export * from './widgets';
+export * from './yamlEditor';
+export * from './core.module';