@spinnaker/core 0.0.0-2025.1-0

package/dist/managed/versionsHistory/VersionContent.d.ts

@@ -0,0 +1,12 @@
+/// <reference types="react" />
+import type { PinnedVersions, VersionData } from './types';
+import './VersionsHistory.less';
+interface IVersionContentProps {
+    versionData: VersionData;
+    pinnedVersions?: PinnedVersions;
+}
+/**
+ * VersionContent includes all of the environments and builds that are associated with a single commit sha (unless if the sha is missing)
+ */
+export declare const VersionContent: ({ versionData, pinnedVersions }: IVersionContentProps) => JSX.Element;
+export {};

package/dist/managed/versionsHistory/VersionHeading.d.ts

@@ -0,0 +1,9 @@
+/// <reference types="react" />
+import type { VersionData } from './types';
+import './VersionsHistory.less';
+interface IVersionHeadingProps {
+    group: VersionData;
+    chevron: JSX.Element;
+}
+export declare const VersionHeading: ({ group, chevron }: IVersionHeadingProps) => JSX.Element;
+export {};

package/dist/managed/versionsHistory/VersionsHistory.d.ts

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

package/dist/managed/versionsHistory/types.d.ts

@@ -0,0 +1,36 @@
+import type { DateTime } from 'luxon';
+import type { FetchVersionQuery, FetchVersionsHistoryQuery } from '../graphql/graphql-sdk';
+export type HistoryEnvironment = NonNullable<FetchVersionsHistoryQuery['application']>['environments'][number];
+export type HistoryArtifact = NonNullable<HistoryEnvironment['state']['artifacts']>[number];
+export type HistoryArtifactVersion = NonNullable<HistoryArtifact['versions']>[number];
+export type SingleVersionEnvironment = NonNullable<FetchVersionQuery['application']>['environments'][number];
+export type SingleVersionArtifact = NonNullable<SingleVersionEnvironment['state']['artifacts']>[number];
+export type SingleVersionArtifactVersion = NonNullable<SingleVersionArtifact['versions']>[number];
+export interface HistoryArtifactVersionExtended extends HistoryArtifactVersion {
+    reference: string;
+    type: string;
+}
+export interface VersionData {
+    type: 'BUILD_NUMBER' | 'SHA';
+    buildNumbers: Set<string>;
+    versions: Set<string>;
+    createdAt?: DateTime;
+    isBaking?: boolean;
+    isFocused?: boolean;
+    environments: {
+        [env: string]: {
+            versions: HistoryArtifactVersionExtended[];
+            isPinned?: boolean;
+            isPreview?: boolean;
+            basedOn?: HistoryEnvironment['basedOn'];
+            gitMetadata?: HistoryEnvironment['gitMetadata'];
+        };
+    };
+    gitMetadata?: HistoryArtifactVersion['gitMetadata'];
+    key: string;
+}
+export interface PinnedVersions {
+    [env: string]: {
+        [artifact: string]: HistoryArtifact['pinnedVersion'];
+    };
+}

package/dist/manifest/ManifestReader.d.ts

@@ -0,0 +1,4 @@
+import type { IManifest } from '../domain';
+export declare class ManifestReader {
+    static getManifest(account: string, location: string, name: string): PromiseLike<IManifest>;
+}

package/dist/manifest/ManifestWriter.d.ts

@@ -0,0 +1,11 @@
+import type { Application } from '../application/application.model';
+import type { ITask } from '../domain';
+export declare class ManifestWriter {
+    static deployManifest(command: any, application: Application): PromiseLike<ITask>;
+    static deleteManifest(command: any, application: Application): PromiseLike<ITask>;
+    static scaleManifest(command: any, application: Application): PromiseLike<ITask>;
+    static undoRolloutManifest(command: any, application: Application): PromiseLike<ITask>;
+    static resumeRolloutManifest(command: any, application: Application): PromiseLike<ITask>;
+    static pauseRolloutManifest(command: any, application: Application): PromiseLike<ITask>;
+    static rollingRestartManifest(command: any, application: Application): PromiseLike<ITask>;
+}

package/dist/manifest/ManifestYaml.d.ts

@@ -0,0 +1,13 @@
+/// <reference types="react" />
+type IManifestYamlProps = {
+    linkName: string;
+    modalTitle: string;
+} & ({
+    manifestText: string;
+    manifestUri?: never;
+} | {
+    manifestText?: never;
+    manifestUri: string;
+});
+export declare function ManifestYaml({ linkName, modalTitle, manifestText, manifestUri }: IManifestYamlProps): JSX.Element;
+export {};

package/dist/manifest/PodNameProvider.d.ts

@@ -0,0 +1,16 @@
+import type { IManifest, IManifestEvent } from '../domain';
+export interface IPodNameProvider {
+    getPodName(): string;
+}
+export declare class DefaultPodNameProvider implements IPodNameProvider {
+    private podName;
+    constructor(podName: string);
+    getPodName(): string;
+}
+export declare class JobEventBasedPodNameProvider implements IPodNameProvider {
+    private manifest;
+    private manifestEvent;
+    constructor(manifest: IManifest, manifestEvent: IManifestEvent);
+    getPodName(): string;
+    private canParsePodName;
+}

package/dist/manifest/index.d.ts

@@ -0,0 +1,6 @@
+export * from './ManifestWriter';
+export * from './ManifestReader';
+export * from './stage/JobStageExecutionLogs';
+export * from './stage/JobManifestPodLogs';
+export * from './ManifestYaml';
+export * from './PodNameProvider';

package/dist/manifest/stage/JobManifestPodLogs.d.ts

@@ -0,0 +1,28 @@
+import React from 'react';
+import type { IPodNameProvider } from '../PodNameProvider';
+import type { IInstanceMultiOutputLog } from '../../instance/InstanceReader';
+export interface IJobManifestPodLogsProps {
+    account: string;
+    location: string;
+    linkName: string;
+    podNamesProviders: IPodNameProvider[];
+}
+export interface IJobManifestPodLogsState {
+    containerLogs: IInstanceMultiOutputLog[];
+    showModal: boolean;
+    selectedContainerLog: IInstanceMultiOutputLog;
+    errorMessage: string;
+    loadingLogs: boolean;
+}
+export declare class JobManifestPodLogs extends React.Component<IJobManifestPodLogsProps, IJobManifestPodLogsState> {
+    private ansiUp;
+    constructor(props: IJobManifestPodLogsProps);
+    private canShow;
+    private resourceRegion;
+    private podName;
+    close(): void;
+    open(): void;
+    onClick(): void;
+    selectLog(log: IInstanceMultiOutputLog): void;
+    render(): JSX.Element;
+}

package/dist/manifest/stage/JobStageExecutionLogs.d.ts

@@ -0,0 +1,25 @@
+import React from 'react';
+import type { IPodNameProvider } from '../PodNameProvider';
+import type { Application } from '../../application';
+import type { IManifest } from '../../domain/IManifest';
+interface IJobStageExecutionLogsProps {
+    deployedName: string;
+    account: string;
+    application: Application;
+    externalLink: string;
+    podNamesProviders: IPodNameProvider[];
+    location: string;
+}
+interface IJobStageExecutionLogsState {
+    manifest?: IManifest;
+}
+export declare class JobStageExecutionLogs extends React.Component<IJobStageExecutionLogsProps, IJobStageExecutionLogsState> {
+    state: {
+        manifest: IManifest;
+    };
+    private destroy$;
+    componentDidMount(): void;
+    private renderExternalLink;
+    render(): JSX.Element;
+}
+export {};

package/dist/modal/buttons/ModalClose.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="react" />
+export declare const ModalClose: ({ dismiss }: {
+    dismiss: () => void;
+}) => JSX.Element;

package/dist/modal/buttons/SubmitButton.d.ts

@@ -0,0 +1,20 @@
+import React from 'react';
+export interface ISubmitButtonProps {
+    className?: string;
+    onClick?: () => void;
+    isDisabled?: boolean;
+    isFormSubmit?: boolean;
+    isNew?: boolean;
+    submitting: boolean;
+    label: string;
+}
+export declare class SubmitButton extends React.Component<ISubmitButtonProps> {
+    static defaultProps: {
+        className: string;
+        onClick: any;
+        isDisabled: boolean;
+        isFormSubmit: boolean;
+        isNew: boolean;
+    };
+    render(): JSX.Element;
+}

package/dist/modal/buttons/modalClose.component.d.ts

@@ -0,0 +1 @@
+export declare const MODAL_CLOSE_COMPONENT = "spinnaker.core.modal.modalClose.component";

package/dist/modal/buttons/submitButton.component.d.ts

@@ -0,0 +1,3 @@
+import type { IComponentOptions } from 'angular';
+export declare const submitButtonComponent: IComponentOptions;
+export declare const SUBMIT_BUTTON_COMPONENT = "spinnaker.core.modal.buttons.submitButton.component";

package/dist/modal/index.d.ts

@@ -0,0 +1,4 @@
+export * from './buttons/ModalClose';
+export * from './buttons/SubmitButton';
+export * from './wizard';
+export { V2_MODAL_WIZARD_COMPONENT, V2ModalWizard } from './wizard/v2modalWizard.component';

package/dist/modal/modal.module.d.ts

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

package/dist/modal/modalOverlay.directive.d.ts

@@ -0,0 +1,2 @@
+export const CORE_MODAL_MODALOVERLAY_DIRECTIVE: "spinnaker.core.modal.modalOverlay.directive";
+export const name: "spinnaker.core.modal.modalOverlay.directive";

package/dist/modal/modalPage.directive.d.ts

@@ -0,0 +1,2 @@
+export const CORE_MODAL_MODALPAGE_DIRECTIVE: "spinnaker.core.modal.modalPage.directive";
+export const name: "spinnaker.core.modal.modalPage.directive";

package/dist/modal/wizard/ModalWizard.d.ts

@@ -0,0 +1,36 @@
+export interface IModalWizardPageState {
+    done: boolean;
+    blocked: boolean;
+    rendered: boolean;
+    current: boolean;
+    dirty: boolean;
+    markCleanOnView: boolean;
+    markCompleteOnView: boolean;
+    required: boolean;
+}
+export interface IModalWizardPage {
+    state: IModalWizardPageState;
+    key: string;
+    label: string;
+}
+export declare class ModalWizard {
+    static renderedPages: IModalWizardPage[];
+    static pageRegistry: IModalWizardPage[];
+    static currentPage: IModalWizardPage;
+    static heading: string;
+    static setHeading(heading: string): void;
+    static getPage(key: string): IModalWizardPage;
+    static markDirty(key: string): void;
+    static markClean(key: string): void;
+    static markComplete(key: string): void;
+    static markIncomplete(key: string): void;
+    static setCurrentPage(page: IModalWizardPage, skipScroll?: boolean): void;
+    static registerPage(key: string, label: string, state?: IModalWizardPageState): void;
+    static renderPages(): void;
+    static isComplete(): boolean;
+    static allPagesVisited(): boolean;
+    static setRendered(key: string, rendered: boolean): void;
+    static includePage(key: string): void;
+    static excludePage(key: string): void;
+    static resetWizard(): void;
+}

package/dist/modal/wizard/WizardModal.d.ts

@@ -0,0 +1,53 @@
+import type { FormikProps } from 'formik';
+import React from 'react';
+import type { WizardPage } from './WizardPage';
+import type { IModalComponentProps } from '../../presentation';
+import type { TaskMonitor } from '../../task/monitor/TaskMonitor';
+export interface IWizardPageInjectedProps<T> {
+    formik: FormikProps<T>;
+    /** WizardModal supplies this incrementor fn, which should be used to supply the WizardPage order prop */
+    nextIdx: () => number;
+    /** The WizardModal Callback API for use by WizardPage component */
+    wizard: IWizardModalApi;
+}
+export interface IWizardModalProps<T> extends IModalComponentProps {
+    formClassName?: string;
+    heading: string;
+    initialValues: T;
+    loading?: boolean;
+    render: (props: IWizardPageInjectedProps<T>) => React.ReactNode;
+    submitButtonLabel: string;
+    taskMonitor: TaskMonitor;
+    validate?(values: T): any;
+}
+export interface IWizardModalState<T> {
+    currentPage: WizardPage<T>;
+    initialized: boolean;
+    pages: Array<WizardPage<T>>;
+}
+export interface IWizardModalApi {
+    onWizardPageAdded: (wizardPage: WizardPage<any>) => void;
+    onWizardPageRemoved: (wizardPage: WizardPage<any>) => void;
+    /**
+     * The wrapped WizardPage component can call this when its state changes
+     * and WizardModal will force a re-render
+     */
+    onWizardPageStateChanged: (_page: WizardPage<any>) => void;
+}
+export declare class WizardModal<T = {}> extends React.Component<IWizardModalProps<T>, IWizardModalState<T>> implements IWizardModalApi {
+    private stepsElement;
+    private formikRef;
+    state: IWizardModalState<T>;
+    private static incrementer;
+    get formik(): FormikProps<T>;
+    componentDidMount(): void;
+    onWizardPageAdded: (wizardPage: WizardPage<T>) => void;
+    onWizardPageRemoved: (wizardPage: WizardPage<T>) => void;
+    private setCurrentPage;
+    private handleStepsScroll;
+    private validate;
+    /** Rerender everything when a WizardPage requests it */
+    onWizardPageStateChanged(_page: WizardPage<T>): void;
+    revalidate: () => Promise<import("formik").FormikErrors<T>>;
+    render(): JSX.Element;
+}

package/dist/modal/wizard/WizardPage.d.ts

@@ -0,0 +1,42 @@
+import React from 'react';
+import type { IWizardModalApi } from './WizardModal';
+export interface IWizardPageComponent<T> {
+    validate(values: T): {
+        [key: string]: any;
+    };
+}
+export interface IWizardPageRenderProps {
+    innerRef: React.RefObject<any>;
+    onLoadingChanged(isLoading: boolean): void;
+}
+export interface IWizardPageProps {
+    label?: string;
+    order: number;
+    note?: React.ReactNode;
+    render: (props: IWizardPageRenderProps) => JSX.Element;
+    wizard: IWizardModalApi;
+}
+interface IWizardPageState {
+    errors: object;
+    order: number;
+    isLoading: boolean;
+    status: WizardPageStatus;
+}
+export type WizardPageStatus = 'default' | 'error' | 'loading';
+export declare class WizardPage<T> extends React.Component<IWizardPageProps, IWizardPageState> {
+    state: IWizardPageState;
+    ref: React.RefObject<HTMLDivElement>;
+    private innerRef;
+    static getStatusClass(status: WizardPageStatus): string;
+    private computeStatus;
+    private onLoadingChanged;
+    validate: (values: any) => {
+        [key: string]: any;
+    };
+    componentDidMount(): void;
+    componentWillUnmount(): void;
+    componentDidUpdate(prevProps: IWizardPageProps): void;
+    private onWizardPageStateChanged;
+    render(): JSX.Element;
+}
+export {};

package/dist/modal/wizard/WizardStepLabel.d.ts

@@ -0,0 +1,11 @@
+import React from 'react';
+import { WizardPage } from './WizardPage';
+interface IWizardStepLabelProps {
+    current: boolean;
+    onClick: (page: WizardPage<any>) => void;
+    page: WizardPage<any>;
+}
+export declare class WizardStepLabel extends React.Component<IWizardStepLabelProps> {
+    render(): JSX.Element;
+}
+export {};

package/dist/modal/wizard/index.d.ts

@@ -0,0 +1,4 @@
+export * from './ModalWizard';
+export * from './WizardModal';
+export * from './WizardPage';
+export * from './WizardStepLabel';

package/dist/modal/wizard/v2modalWizard.component.d.ts

@@ -0,0 +1,14 @@
+import type { IController } from 'angular';
+import './modalWizard.less';
+export declare class V2ModalWizard implements IController {
+    private $scope;
+    wizard: any;
+    heading: string;
+    taskMonitor: any;
+    dismiss: () => any;
+    static $inject: string[];
+    constructor($scope: ng.IScope);
+    $onInit(): void;
+    $onDestroy(): void;
+}
+export declare const V2_MODAL_WIZARD_COMPONENT = "spinnaker.core.modal.wizard.wizard.component";

package/dist/modal/wizard/v2wizardPage.component.d.ts

@@ -0,0 +1,67 @@
+import type { IController } from 'angular';
+import type { IModalWizardPageState } from './ModalWizard';
+/**
+ * Wizard page directive
+ * possible attributes:
+ *   - key (required): Any string value, unique within the wizard; it becomes the the hook to access the page state
+ *     through the wizard, e.g. wizard.getPage('page-1').markComplete()
+ *   - label (required): Any string value; it becomes label in the wizard flow
+ *   - done (optional, default: false): when set to true, the page will be marked complete when rendered
+ *   - mandatory (optional, default: true): when set to false, the wizard will not consider this page when isComplete
+ *     is called
+ *   - render (optional, default: true): when set to false, registers the page with the wizard, but does not participate
+ *     in the wizard flow. To add the page to the flow, call wizard.includePage(key)
+ *   - markCompleteOnView (optional, default: true): when set to false, the page will not be marked complete when
+ *     scrolled into view
+ */
+export declare class WizardPageController implements IController {
+    private $scope;
+    /**
+     * when set to false, the wizard will not consider this page when isComplete is called
+     * default: false
+     * @type {boolean}
+     */
+    mandatory: boolean;
+    /**
+     * when set to true, the page will be marked complete when rendered
+     * default: false
+     * @type {boolean}
+     */
+    done: boolean;
+    /**
+     * when set to false, the page will not be marked clean when scrolled into view
+     * default: true
+     * @type {boolean}
+     */
+    markCleanOnView: boolean;
+    /**
+     * when set to false, the page will not be marked complete when scrolled into view
+     * default: true
+     * @type {boolean}
+     */
+    markCompleteOnView: boolean;
+    /**
+     * Any string value, unique within the wizard; it becomes the the hook to access the page state through the wizard,
+     * e.g. wizard.getPage('page-1').markComplete()
+     */
+    key: string;
+    /**
+     * Any string value; it becomes label in the wizard flow
+     */
+    label: string;
+    /**
+     * when set to false, registers the page with the wizard, but does not participate in the wizard flow.
+     * To add the page to the flow, call wizard.includePage(key)
+     * default: true
+     * @type {boolean}
+     */
+    render: boolean;
+    /**
+     * Internal state of the page, initialized based on other public fields
+     */
+    state: IModalWizardPageState;
+    static $inject: string[];
+    constructor($scope: ng.IScope);
+    $onInit(): void;
+}
+export declare const V2_WIZARD_PAGE_COMPONENT = "spinnaker.core.modal.wizard.wizardPage.component";

package/dist/modal/wizard/wizardSubFormValidation.service.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Propagates standard Angular form validation to ModalWizard.
+ */
+export const CORE_MODAL_WIZARD_WIZARDSUBFORMVALIDATION_SERVICE: "spinnaker.core.modalWizard.subFormValidation.service";
+export const name: "spinnaker.core.modalWizard.subFormValidation.service";

package/dist/naming/IMoniker.d.ts

@@ -0,0 +1,7 @@
+export interface IMoniker {
+    app: string;
+    cluster?: string;
+    detail?: string;
+    stack?: string;
+    sequence?: number;
+}

package/dist/naming/index.d.ts

@@ -0,0 +1,2 @@
+export * from './IMoniker';
+export * from './nameUtils';

package/dist/naming/nameUtils.d.ts

@@ -0,0 +1,20 @@
+import type { IMoniker } from './IMoniker';
+import type { Application } from '../application';
+export interface IComponentName {
+    application: string;
+    stack: string;
+    freeFormDetails: string;
+    cluster: string;
+}
+export declare class NameUtils {
+    static VERSION_PATTERN: RegExp;
+    static parseServerGroupName(serverGroupName: string): IComponentName;
+    static parseClusterName(clusterName: string): IComponentName;
+    static getClusterName(app: string, stack: string, detail: string): string;
+    static getClusterNameFromServerGroupName(serverGroupName: string): string;
+    static getSequence(monikerSequence: number): string;
+    static parseLoadBalancerName(loadBalancerName: string): IComponentName;
+    static parseSecurityGroupName(securityGroupName: string): IComponentName;
+    static getMoniker(app: string, stack: string, detail: string): IMoniker;
+    static getMonikerForInstance(cloudProvider: string, instanceId: string, app: Application): PromiseLike<IMoniker>;
+}

package/dist/navigation/UrlBuilder.d.ts

@@ -0,0 +1,31 @@
+import type { StateService } from '@uirouter/core';
+import type { ITask } from '../domain';
+export interface IUrlBuilderInput {
+    account?: string;
+    application?: string;
+    cluster?: string;
+    detail?: string;
+    instanceId?: string;
+    loadBalancer?: string;
+    name?: string;
+    namespace?: string;
+    project?: string;
+    provider?: string;
+    region?: string;
+    serverGroup?: string;
+    stack?: string;
+    taskId?: string;
+    type: string;
+    vpcId?: string;
+}
+export interface IUrlBuilder {
+    build: (input: IUrlBuilderInput, $state: StateService) => string;
+}
+export declare class UrlBuilder {
+    private $state;
+    private createCloneTask;
+    private asgTask;
+    constructor($state: StateService);
+    static buildFromMetadata(input: IUrlBuilderInput): string;
+    buildFromTask(task: ITask): string | boolean;
+}

package/dist/navigation/UrlBuilderRegistry.d.ts

@@ -0,0 +1,6 @@
+import type { IUrlBuilder } from './UrlBuilder';
+export declare class UrlBuilderRegistry {
+    private builders;
+    register(key: string, builder: IUrlBuilder): void;
+    getBuilder(key: string): IUrlBuilder;
+}

package/dist/navigation/index.d.ts

@@ -0,0 +1,4 @@
+export * from './state.provider';
+export * from './UrlBuilderRegistry';
+export * from './UrlBuilder';
+export * from './urlParser';

package/dist/navigation/state.provider.d.ts

@@ -0,0 +1,54 @@
+/// <reference types="react" />
+import type { Ng1StateDeclaration, Ng1ViewDeclaration, ParamDeclaration, UrlRouterProvider } from '@uirouter/angularjs';
+import type { ParamTypeDefinition, ReactViewDeclaration } from '@uirouter/react';
+import type { IServiceProvider } from 'angular';
+import type { IFilterConfig } from '../filterModel/IFilterModel';
+import type { StateHelper } from './stateHelper.provider';
+import './navigation.less';
+export interface IReactHybridIntermediate extends Ng1StateDeclaration {
+    children?: INestedState[];
+    component?: any;
+    views?: {
+        [key: string]: any;
+    };
+}
+export interface INestedState extends IReactHybridIntermediate {
+    children?: INestedState[];
+    component?: React.ComponentType | string;
+    views?: {
+        [key: string]: ReactViewDeclaration | Ng1ViewDeclaration;
+    };
+}
+export declare class StateConfigProvider implements IServiceProvider {
+    private $urlRouterProvider;
+    private stateHelperProvider;
+    private root;
+    static $inject: string[];
+    constructor($urlRouterProvider: UrlRouterProvider, stateHelperProvider: StateHelper);
+    /**
+     * Adds a root state, e.g. /applications, /projects, /infrastructure
+     * @param child the state to add
+     */
+    addToRootState(child: INestedState): void;
+    /**
+     * registers any states that have been added as children to an already-registered state
+     * (really just called internally by #addToRootState and by the ApplicationStateProvider methods)
+     */
+    setStates(): void;
+    /**
+     * Configures a rewrite rule to automatically replace a base route
+     * @param base, e.g. "/applications/{application}"
+     * @param replacement, e.g. "/applications/{application}/clusters"
+     */
+    addRewriteRule(base: string | RegExp, replacement: string | Function): void;
+    buildDynamicParams(paramConfig: IFilterConfig[]): {
+        [key: string]: ParamDeclaration | any;
+    };
+    paramsToQuery(paramConfig: IFilterConfig[]): string;
+    $get(): StateConfigProvider;
+}
+export declare const trueKeyObjectParamType: ParamTypeDefinition;
+export declare const inverseBooleanParamType: ParamTypeDefinition;
+export declare const booleanParamType: ParamTypeDefinition;
+export declare const sortKeyParamType: ParamTypeDefinition;
+export declare const STATE_CONFIG_PROVIDER = "spinnaker.core.navigation.state.config.provider";

package/dist/navigation/stateHelper.provider.d.ts

@@ -0,0 +1,14 @@
+/// <reference types="angular" />
+import type { StateRegistry } from '@uirouter/core';
+import type { INestedState } from './state.provider';
+export declare class StateHelper implements ng.IServiceProvider {
+    private $stateRegistryProvider;
+    private registeredStates;
+    static $inject: string[];
+    constructor($stateRegistryProvider: StateRegistry);
+    setNestedState(state: INestedState, keepOriginalNames?: boolean): void;
+    private fixStateName;
+    private fixStateViews;
+    $get(): StateHelper;
+}
+export declare const STATE_HELPER = "spinnaker.core.navigation.stateHelper.provider";

package/dist/navigation/urlParser.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Based 100% on Angular internals
+ */
+export type QueryParamVal = string | boolean | any[];
+export interface IQueryParams {
+    [key: string]: QueryParamVal;
+}
+export declare class UrlParser {
+    /**
+     * Parses an escaped url query string into key-value pairs.
+     * @returns {Object.<string,boolean|Array>}
+     */
+    static parseQueryString(query?: string): IQueryParams;
+    private static tryDecodeURIComponent;
+}