@microsoft/windows-admin-center-sdk/core/manifest/environment-modules.d.ts

Microsoft - Windows Admin Center Shell

import { PowerShellCommand } from '../data/powershell';
/**
 * Defines an object or property for other extensions to reference
 */
export interface EnvironmentModulePropertyDescriptor {
    /**
     * The type of value of this property.
     * required if schema is not defined.
     */
    type?: 'array' | 'boolean' | 'null' | 'object' | 'number' | 'string';
    /**
     * A reference to a schema resource defining this property
     */
    schema?: string;
    /**
     * Tells other extension developers more information about this property
     */
    comment?: string;
    /**
     * Indicates if this field is required
     */
    required?: boolean;
    /**
     * The default value of this property
     * The type should be of the same type defined in the 'type' property.
     */
    defaultsTo?: any;
    /**
     * The contract for the array items.
     * Required if the type property is set to 'array'
     */
    items?: EnvironmentModulePropertyDescriptor;
    /**
     * The contract for the sub properties.
     * Required if the type property is set to 'object'
     */
    properties?: MsftSme.StringMap<EnvironmentModulePropertyDescriptor>;
}
export interface EnvironmentModuleDisplayable {
    /**
     * display name of module
     */
    displayName: string;
    /**
     * description of module
     */
    description: string;
    /**
     * icon url or smeIcon reference. Absolute or relative urls
     */
    icon: string;
    /**
     * The scale of icon. (1.0 is default if not specified)
     */
    iconScale?: number;
    /**
     * The dark theme data. (Optional)
     */
    darkTheme?: {
        /**
         * The icon path on the package.
         */
        icon: string;
        /**
         * The scale of icon. (1.0 is default if not specified)
         */
        iconScale?: number;
    };
    /**
     * keywords for module search
     */
    keywords: string[];
}
/**
 * The type of entry point.
 */
export declare enum EnvironmentModuleEntryPointType {
    ConnectionProvider = "connectionProvider",
    Solution = "solution",
    Tool = "tool",
    Service = "service",
    SettingsForm = "settingsForm",
    GroupProvider = "groupProvider",
    Worker = "worker",
    Dialog = "dialog",
    SnapIn = "snapIn"
}
/**
 * The type of behavior to solution root navigation.
 */
export declare type SolutionRootNavigationBehaviorType = 'path' | 'connections' | 'tools';
/**
 * The interface of condition check of server inventory data.
 */
export interface EnvironmentModuleConditionStatement {
    /**
     * The operator of the condition.
     */
    operator: 'gt' | 'ge' | 'lt' | 'le' | 'eq' | 'ne' | 'is' | 'not' | 'contains' | 'notContains' | 'anyEq' | 'anyNe' | 'anyContains' | 'anyNotContains';
    /**
     * The data type of value.
     */
    type: 'version' | 'number' | 'string' | 'boolean' | 'numberArray' | 'stringArray';
    /**
     * The test value of the condition.
     */
    value: string | number | boolean | number[] | string[];
}
/**
 * The mapped inventory conditions.
 */
export declare type EnvironmentModuleConditionMap = MsftSme.StringMap<EnvironmentModuleConditionStatement>;
/**
 * The requirement of entry point to be activated on the view.
 */
export interface EnvironmentModuleEntryPointRequirement {
    /**
     * The id of solutions of the connection type that satisfies this requirement.
     */
    solutionIds?: string[];
    /**
     * The id of the connection type that satisfies this requirement
     */
    connectionTypes?: string[];
    /**
     * The conditions of tool status.
     */
    conditions?: {
        /**
         * Check if app/desktop localhost. Only tested if it sets "false".
         */
        localhost?: boolean;
        /**
         * Check if specific condition against ServerInventory data.
         */
        inventory?: EnvironmentModuleConditionMap;
        /**
         * Check if specific condition against supported installation type data.
         */
        installationTypes?: string[];
        /**
         * Check if specific condition against Connection properties data.
         */
        properties?: EnvironmentModuleConditionMap;
        /**
         * @deprecated
         * Check by using PowerShell script.
         *
         * must return the following format.
         * {
         *   state: 'Available', 'NotConfigured', 'NotSupported'
         *   message: string
         *   keyValuePairs: [ { name: string, value: string, type: string } ]
         * }
         */
        script?: string;
        /**
         * Check by using PowerShell script and command.
         *
         * must return the following format.
         * {
         *   state: 'Available', 'NotConfigured', 'NotSupported'
         *   message: string
         *   keyValuePairs: [ { name: string, value: string, type: string } ]
         * }
         */
        powerShell?: PowerShellCommand;
    }[];
}
/**
 * Defines an object that describes the identity of an extension method
 */
export interface ExtensionMethodIdentifier {
    /**
     * The name of the module in which the extension method can be found
     */
    module: string;
    /**
     * The name of the entry point in which the extension method can be found
     */
    name: string;
    /**
     * The method to find
     */
    method: string;
    /**
     * The version of the method to be found
     */
    version: number;
}
/**
 * Defines an object that describes the identity of an extension dialog
 */
export interface ExtensionDialogIdentifier {
    /**
     * The name of the module in which the extension dialog can be found
     */
    module: string;
    /**
     * The name of the entry point of the extension dialog
     */
    name: string;
    /**
     * The version of the dialog
     */
    version: number;
}
export interface EnvironmentModuleConnectionStatusProvider {
    /**
     * If defined, powershell will be used to query a connections status
     */
    powerShell?: PowerShellCommand;
    /**
     * If defined, the gateways REST api will be used to query a connections status
     */
    relativeGatewayUrl?: string;
    /**
     * Specifies to get the connection status from a worker extension method.
     * The worker method is expected to take a connection name as its only input
     */
    worker?: ExtensionMethodIdentifier;
    /**
     * Specifies to get the connection status from a service extension method.
     * The service method is expected to take a connection name as its only input
     */
    service?: ExtensionMethodIdentifier;
    /**
     * If defined, will be used to look up display strings for the label and description of the status object
     */
    displayValueMap?: MsftSme.StringMap<string>;
    /**
     * If defined, will be used to skip status checks
     */
    skipStatusCheck?: boolean;
}
export interface SolutionConnectionsViewConfiguration {
    /**
     * List of connections types to show in the view of the connections list
     * each entry should be a valid connection type string identifier from any
     * modules entrypoints of type @see EnvironmentModuleEntryPointType.ConnectionProvider
     */
    connectionTypes: string[];
    /**
     * The title of the connections list for this solution.
     * Optional. A default header will be provided if this field is left out
     */
    header?: string;
}
export interface SolutionToolsViewConfiguration {
    /**
     * Enables/Disable ths tools menu
     */
    enabled: boolean;
    /**
     * Sets the title of the tools menu
     */
    title: string;
    /**
     * Sets the title of the search field on the tools menu
     */
    searchTitle: string;
    /**
     * Indicates the default tool to open if no tool is provided. This value should be the name of an entrypoint in the same module
     */
    defaultTool: string;
    /**
     * The list of known tools that will be displayed at the first section of tool menu.
     * 1) entry and group are mandatory.
     * 2) create groups and sort members by priority then alphabetical.
     * 3) sort the groups by highest priority number in the group members.
     * 4) settings creates single group and sort members by priority then alphabetical.
     */
    predefined: {
        /**
         * The entry point ID with "<module name>!<entry point name>" format.
         */
        id: string;
        /**
         * The group display name.
         */
        group: string;
        /**
         * The ordering priority.
         * (0 is highest)
         */
        priority?: number;
        /**
         * Indicating the tool is settings menu.
         */
        settings?: boolean;
    }[];
}
/**
 * Defines the configuration for a connection provider experience
 */
export interface ConnectionProviderExperienceConfiguration {
    /**
     * The path to the experience.
     */
    path: string;
    /**
     * The label to display for the experience.
     * ex) Add Server Connection, Create Failover Cluster Connection and so on.
     */
    label: string;
    /**
     * The dialog mode to use for the dialog that contains this experience
     */
    dialogMode?: 'normal' | 'wide' | 'compact' | 'fullscreen';
}
/**
 * The type of lifetime to implement when creating a worker
 */
export declare type WorkerLifetime = 'default' | 'long';
/**
 * The type of startup type to implement when creating a service
 */
export declare type ServiceStartupType = 'automatic' | 'onDemand';
/**
 * The type of cleanup type to implement when creating a service
 * 'never' means that that service will start and only be destroyed if specifically requested or the application ends
 * 'onIdle' means that the shell will clean up the service when no one has used it within a certain time limit.
 * This time limit is currently controlled by the shell.
 */
export declare type ServiceCleanupType = 'never' | 'onIdle';
/**
 * Defines the target of an entry point
 */
export interface ExtenderDefinition {
    /**
     * The module to target
     */
    module: string;
    /**
     * The name of the extension target (within the 'module') to provide this entry point to
     */
    target: string;
}
/**
 * Defines the target of a worker entry point
 */
export interface WorkerExtenderDefinition extends ExtenderDefinition {
    /**
     * A map of method names to the versions that are implemented in this worker
     */
    methodVersions: MsftSme.StringMap<number>;
}
/**
 * Describes the method contract exposed by a worker for other modules to call.
 * When making breaking changes, make sure to use the version properties so dependent modules still work with an older contract
 */
export interface ExtensionMethodContract {
    /**
     * The version of this method. Create a new version for every breaking change
     */
    version?: number;
    /**
     * The name of the method
     */
    method: string;
    /**
     * a comment describing this method to consumers
     */
    comment?: string;
    /**
     * Defines the arguments expected to be passed to this method
     */
    arguments?: MsftSme.StringMap<EnvironmentModulePropertyDescriptor>;
    /**
     * Defines the contract that this method will return
     */
    returns: EnvironmentModulePropertyDescriptor;
}
/**
 * Describes the declaration for a dialog
 * When making breaking changes, make sure to use the version properties so dependent modules still work with an older contract
 */
export interface DialogExtensionDeclaration {
    /**
     * The version of this method. Create a new version for every breaking change
     */
    version?: number;
    /**
     * a comment describing this dialog to consumers
     */
    comment?: string;
    /**
    * The dialog mode to use for the dialog
    */
    dialogMode?: 'pane' | 'wide-pane' | 'compact' | 'compact-square' | 'fullscreen' | 'centered' | 'centered-large';
    /**
     * Defines the arguments expected to be passed to this method
     */
    arguments?: MsftSme.StringMap<EnvironmentModulePropertyDescriptor>;
    /**
     * Defines the contract that this dialog will return
     */
    returns: EnvironmentModulePropertyDescriptor;
}
/**
 * Define the minimum and maximum footprint of a snap in
 */
export interface SnapInSizeConstraints {
    minWidth: number;
    minHeight: number;
    maxWidth: number;
    maxHeight: number;
}
/**
 * Define the component interaction of inputs and outputs between the entry point and its consumer
 */
export interface ExtensionInteraction {
    /**
    * The version of this interaction. Create a new version for every breaking change
    */
    version?: number;
    /**
     * a comment describing this interaction model
     */
    comment?: string;
    /**
     * Defines the inputs that can be passed to this entry point
     */
    inputs?: MsftSme.StringMap<EnvironmentModulePropertyDescriptor>;
    /**
     * Defines the outputs that this entry point can return
     */
    outputs?: MsftSme.StringMap<EnvironmentModulePropertyDescriptor>;
}
/**
 * The type of lifetime to implement when creating a worker
 */
export declare enum ExtensionTargetType {
    WorkerTarget = "workerTarget"
}
export interface ExtensionTarget {
    /**
     * The type of extension target
     */
    extensionTargetType: ExtensionTargetType;
    /**
     * Description of the workerTarget.
     * This should tell the consumer what workers who target this are expected to do.
     */
    description: string;
    /**
     * The name of this extension target.
     * Should be unique to this modules other extension targets
     */
    name: string;
    /**
     * Mapping to the parent module of this target
     */
    parentModule?: EnvironmentModule;
}
export interface WorkerExtensionTarget extends ExtensionTarget {
    /**
     * The type of extension target
     */
    extensionTargetType: ExtensionTargetType.WorkerTarget;
    /**
     * worker only -- The contract that is expected to be fulfilled by worker entry points that extend this target
     */
    contract: ExtensionMethodContract[];
}
/**
 * Defines the provider for collecting active managing as information
 */
export interface ManagingAsProvider {
    /**
     * If Defined, Specifies to collect managing as data from a worker method
     */
    worker?: ExtensionMethodIdentifier;
    /**
     * If Defined, Specifies to collect managing as data from a service method
     */
    service?: ExtensionMethodIdentifier;
}
/**
 * Defines how to apply manage as scenarios to this connection type
 */
export interface EnvironmentModuleManageAsScheme {
    /**
     * If Defined, Specifies to configure manage as credentials from an extension dialog
     */
    configurationDialog: ExtensionDialogIdentifier;
    /**
     * If Defined, Specifies how to collect active managing as data
     */
    managingAsProvider: ManagingAsProvider;
}
/**
 * Defines a modules entry point
 */
export interface EnvironmentModuleEntryPoint extends EnvironmentModuleDisplayable {
    /**
     * The type of entry point.
     */
    entryPointType: EnvironmentModuleEntryPointType;
    /**
     * The name of entry point, unique to its parent module
     */
    name?: string;
    /**
     * The friendly url name to use to reference this entrypoint. This must be unique among all entrypoints
     */
    urlName?: string;
    /**
     * The path of entry point.
     */
    path: string;
    /**
     * The frame Id to share single iframe within the module.
     */
    iframeId?: string;
    /**
     * Experiment keys that must all be enabled to enable this entry point
     */
    experimentKeys?: string[];
    /**
     * The id of the group provider.
     * Used to indicate which group provider should be used for grouping extensions
     */
    groupId?: string;
    /**
     * @see EnvironmentModuleEntryPointType.ConnectionProvider types only.
     * NOTE: This SHOULD be for SOLUTION types. since a connection type can exist in multiple solutions.
     * If true, the search bar will shown the tools list for this connection type
     * Otherwise, search bar will be hidden. Default is true.
     */
    searchBar?: boolean;
    /**
     * @see EnvironmentModuleEntryPointType.ConnectionProvider types only.
     * Alternative to providing "path".
     * Configures the experiences for manipulating the connections provided by this entry point
     */
    experiences: {
        add: ConnectionProviderExperienceConfiguration;
        create: ConnectionProviderExperienceConfiguration;
    };
    /**
     * @see EnvironmentModuleEntryPointType.ConnectionProvider types only.
     * The id of the connection type that this entry point provides
     */
    connectionType?: string;
    /**
     * @see EnvironmentModuleEntryPointType.ConnectionProvider types only.
     * The friendly url name to use to reference the connection type that this entry point provides.
     * This must be unique among all connection types
     */
    connectionTypeUrlName?: string;
    /**
     * @see EnvironmentModuleEntryPointType.ConnectionProvider types only.
     * The display name of the connection type that this entry point provides
     */
    connectionTypeName?: string;
    /**
     * @see EnvironmentModuleEntryPointType.ConnectionProvider types only.
     * The default solution to use when opening the connection type that this entry point provides
     */
    connectionTypeDefaultSolution?: string;
    /**
     * @see EnvironmentModuleEntryPointType.ConnectionProvider types only.
     * The status provider implementation for the connection type that this entry point provides
     */
    connectionStatusProvider?: EnvironmentModuleConnectionStatusProvider;
    /**
     * @see EnvironmentModuleEntryPointType.ConnectionProvider types only.
     * The manage as scheme to use for changing how the connection is managed
     */
    manageAsScheme?: EnvironmentModuleManageAsScheme;
    /**
     * @see EnvironmentModuleEntryPointType.Tool types only.
     * A list of requirements, if any requirement is met then this tool is applicable to a given connection
     */
    requirements?: EnvironmentModuleEntryPointRequirement[];
    /**
     * Mapping to the parent module of this entry point
     */
    parentModule?: EnvironmentModule;
    /**
     * @see EnvironmentModuleEntryPointType.Solution types only.
     * Defines how navigating to the root of this solution will behave.
     * Setting this to 'path' will load this module to the 'path' property.
     * Setting this to 'connections' will navigate instead to the connections list, customized for this solution
     */
    rootNavigationBehavior?: SolutionRootNavigationBehaviorType;
    /**
     * @see EnvironmentModuleEntryPointType.Solution types only.
     * Only applicable when 'rootNavigationBehavior' us set to 'connections'.
     * Describes how to customize the view of the connections list.
     */
    connections?: SolutionConnectionsViewConfiguration;
    /**
     * @see EnvironmentModuleEntryPointType.Solution types only. If provided, Configures the tools menu for this solution.
     */
    tools?: SolutionToolsViewConfiguration;
    /**
     * @see EnvironmentModuleEntryPointType.Worker types only. If provided, Configures the lifetime of this worker.
     */
    lifetime?: WorkerLifetime;
    /**
     * @see EnvironmentModuleEntryPointType.Service types only. If provided, Configures the startup type of this service.
     */
    startupType?: ServiceStartupType;
    /**
     * @see EnvironmentModuleEntryPointType.Service types only. If provided, Configures the cleanup of this service.
     */
    cleanupType?: ServiceCleanupType;
    /**
     * Defines specific extensionTargets to provide this entry point to
     */
    extends?: ExtenderDefinition[];
    /**
     * @see EnvironmentModuleEntryPointType.Worker and @see EnvironmentModuleEntryPointType.Service types only.
     * Describes the method contracts exposed by this worker or service for other modules to call.
     */
    exposes?: ExtensionMethodContract[];
    /**
     * @see EnvironmentModuleEntryPointType.Dialog types only
     * Defines the declaration for this dialog - inputs and outputs.
     */
    declaration?: DialogExtensionDeclaration[];
    /**
     * @see EnvironmentModuleEntryPointType.SnapIn types only
     * Defines the size requirements for this snap in
     */
    sizeConstrains?: SnapInSizeConstraints;
    /**
     * @see EnvironmentModuleEntryPointType.SnapIn types only
     * Defines the component interaction model for the snap in
     */
    interaction?: ExtensionInteraction;
    /**
     * @see EnvironmentModuleEntryPointType.SnapIn types only
     * Defines the author of the snap in.
     */
    author?: string;
}
/**
 * The state definition of Tool condition.
 */
export declare enum EnvironmentModuleToolState {
    /**
     * Tool is available on the connection.
     */
    Available = 0,
    /**
     * Tool is not available because it's not configured properly.
     */
    NotConfigured = 1,
    /**
     * Tool it not supported on the connection.
     */
    NotSupported = 2
}
/**
 * The result of Tool conditions.
 */
export interface EnvironmentModuleToolConditionResult {
    /**
     * Display the tool.
     */
    show: boolean;
    /**
     * The connection id of node.
     */
    connectionId?: string;
    /**
     * The state of tool condition.
     */
    detail?: EnvironmentModuleToolState;
    /**
     * The message of condition.
     */
    message?: string;
}
/**
 * Tool's combined entry point and inventory result.
 */
export interface EnvironmentModuleEntryPointWithToolConditionResult extends EnvironmentModuleEntryPoint, EnvironmentModuleToolConditionResult {
}
/**
 * Environment module resource class.
 */
export interface EnvironmentModuleResource {
    /**
     * locale key string.
     */
    locale: string;
    /**
     * string map object.
     */
    strings: MsftSme.StringMap<string>;
}
export declare const defaultEnvironmentConfiguration: MsftSme.EnvironmentConfiguration;
/**
 * Defines an object that provides information about a connection type.
 */
export interface EnvironmentConnectionTypeInfo {
    /**
     * The provider entry point.
     */
    provider: EnvironmentModuleEntryPoint;
    /**
     * The solution entry point.
     */
    solution: EnvironmentModuleEntryPoint;
}
export interface EnvironmentModuleFriendlyUrlMap {
    to: MsftSme.StringMap<string>;
    from: MsftSme.StringMap<string>;
}
export interface EnvironmentModuleFriendlyUrlMaps {
    connectionTypes: EnvironmentModuleFriendlyUrlMap;
    solutions: EnvironmentModuleFriendlyUrlMap;
    tools: EnvironmentModuleFriendlyUrlMap;
    settingsForms: EnvironmentModuleFriendlyUrlMap;
}
/**
 * Environment module class.
 */
export declare class EnvironmentModule {
    private static readonly logSourceName;
    /**
     * Static mapping for connection information.
     */
    private static connectionMap;
    /**
     * Static mapping for extensionTargetTypes to a map of extensionTargetIds to entry point ids that fulfill that target
     */
    private static extensionTargetFulfillmentMap;
    /**
     * Static mapping for friendly url strings to entrypoint ids
     */
    private static friendlyUrlMap;
    /**
     * The name of shell.
     */
    static nameOfShell: string;
    /**
     * The default signature if missing manifest.
     */
    static defaultSignature: string;
    /**
     * The prefix for identifying an sme-icon reference
     */
    static smeIconPrefix: string;
    /**
     * All entry points from all modules
     */
    static allEntryPoints: EnvironmentModuleEntryPoint[];
    /**
     * All entry points by type
     */
    static entryPointsByType: MsftSme.StringMap<EnvironmentModuleEntryPoint[]>;
    /**
     * All entry points by type
     */
    static entryPointsById: MsftSme.StringMap<EnvironmentModuleEntryPoint>;
    /**
     * All extension targets from all modules
     */
    static allExtensionTargets: ExtensionTarget[];
    /**
     * All extension targets by type
     */
    static extensionTargetsByType: MsftSme.StringMap<ExtensionTarget[]>;
    /**
     * All extension targets by type
     */
    static extensionTargetsById: MsftSme.StringMap<ExtensionTarget>;
    /**
     * All extension targets by type
     */
    static extensionOrigins: Set<String>;
    /**
     * schema file information.
     */
    $schema?: string;
    /**
     * name of module.
     */
    name: string;
    /**
     * display name of module.
     */
    displayName: string;
    /**
     * description of set of tools.
     */
    description?: string;
    /**
     * keywords of the module.
     */
    keywords?: string[];
    /**
     * origin absolute url.
     */
    origin: string;
    /**
     * target url to open the iframe.
     */
    target?: string;
    /**
     * signature.
     */
    signature: string;
    /**
     * The version of this module
     */
    version: string;
    /**
     * icon url, absolute or relative to Shell url.
     */
    icon?: string;
    /**
     * The support JEA endpoint with PowerShell module.
     */
    jea?: boolean;
    /**
     * extension targets for this extension
     * Defines things that can be extended in this module.
     */
    extensionTargets?: ExtensionTarget[];
    /**
     * entry points to launch the tool.
     */
    entryPoints: EnvironmentModuleEntryPoint[];
    /**
     * Assets shared by the module
     */
    assets?: MsftSme.MsftSmeModuleAssets;
    /**
     * localized resources of strings.
     */
    resources: EnvironmentModuleResource[];
    /**
     * Schemas provided for use in this manifest
     */
    schemas?: MsftSme.StringMap<EnvironmentModulePropertyDescriptor>;
    /**
     * list of all other available modules for shell.
     */
    modules?: EnvironmentModule[];
    /**
     * Indicates that this module is being sideLoaded
     */
    isSideLoaded?: boolean;
    /**
     * The Environment configuration
     */
    configuration: MsftSme.EnvironmentConfiguration;
    /**
     * returns true if the provided origin is a known extension origin
     */
    static isExtensionOrigin(origin: string): boolean;
    /**
     * Indicates if a given icon reference is an sme-icon or some other form
     * @param iconRef the reference to check
     */
    static isSmeIconRef(iconRef: string): boolean;
    /**
     * Gets the icon class from an iconRef or returns null if the iconRef is not an sme-icon reference
     * @param iconRef the reference to check
     */
    static getSmeIconClassFromRef(iconRef: string): string;
    /**
     * Gets the icon url from an iconRef or returns null if the iconRef is an sme-icon reference
     * @param iconRef the reference to check
     */
    static getFormattedIconRefUrl(iconRef: string): string;
    /**
     * Processes an icon reference to resolve it to either a sme-icon or absolute url
     * @param iconRef The icon reference
     * @param module the module that the icon belongs to
     */
    static processIconReference(iconRef: string, module: EnvironmentModule): string;
    /**
     * Converts relative module paths into absolute uris
     */
    private static toAbsolutePath;
    /**
     * Find resource string for the key.
     *
     * @param resources The resource.
     * @param locale The locale.
     * @param key The key string.
     */
    static findResource(resources: EnvironmentModuleResource[], locale: string, key: string): string;
    /**
     * Recursively processes manifest resources
     *
     * @param module the manifest object.
     * @param locale the locale string such as 'en'.
     * @param obj current object, defaults to the module itself
     */
    private static processModuleResources;
    static getModuleAssetUri(moduleName: string, resourceName: string, version: string): string;
    /**
     * Create environment object from the manifest.
     *
     * @param manifest the manifest object.
     * @param locale the locale string such as 'en'.
     */
    static createEnvironment(manifest: any, locale: string): any;
    /**
     * Gets the environment module.
     *
     * @param name the name of module.
     * @return EnvironmentModule the environment module.
     */
    static checkEnvironmentInitialized(): void;
    /**
     * Gets the environment module.
     *
     * @param name the name of module.
     * @return EnvironmentModule the environment module.
     */
    static getEnvironmentModule(name: string): EnvironmentModule;
    /**
     * Process extension targets for quick and easy access later
     * @param module the modules to process
     */
    private static processExtensionTargets;
    /**
     * Process Entry points for quick and easy access later
     * @param module the modules to process
     */
    private static processEntryPoints;
    /**
     * Evaluates all of the modules in the environment and returns a flat list of all of their entry points.
     * optionally filtered by the 'filter' function
     *
     * @param filter the filter to apply to the entry points.
     * @return a flat list of all module entry points
     */
    private static getExtensionTargets;
    /**
     * Evaluates all of the modules in the environment and returns a flat list of all of their entry points.
     * optionally filtered by the 'filter' function
     *
     * @param filter the filter to apply to the entry points.
     * @return a flat list of all module entry points
     */
    static getEntryPoints(filter?: (entryPoint: EnvironmentModuleEntryPoint) => boolean): EnvironmentModuleEntryPoint[];
    /**
     * Gets the available entry points from all of the modules in the environment, filtered by type.
     *
     * @param name the name of module.
     * @return EnvironmentModule the environment module.
     */
    static getEntryPointsByType(entryPointTypes: EnvironmentModuleEntryPointType[]): EnvironmentModuleEntryPoint[];
    /**
     * Gets the connection type mapping data.
     *
     * @return the mapping object.
     */
    static fulfillExtensionTarget(extensionTargetId: any): string[];
    /**
     * Gets the connection type mapping data.
     *
     * @return the mapping object.
     */
    static getConnectionMap(): {
        [name: string]: EnvironmentConnectionTypeInfo;
    };
    /**
     * Gets a friendly url segment from a connection type
     * @param connectionType the connection type to map.
     * @return string friendly url for the connection type or the connection type if no friendly name exists.
     */
    static getFriendlyUrlSegmentForConnectionType(connectionType: string, fallbackToUnfriendlySegment?: boolean): string;
    /**
     * Gets a connection type from a friendly url segment
     * @param urlSegment the url segment to map
     * @return string connection type found using the friendly url segment
     */
    static getConnectionTypeFromFriendlyUrlSegment(urlSegment: string): string;
    /**
     * Gets a friendly url segment from an entry point id
     * @param urlSegment the url segment.
     * @param entryPointType the type of entry point to look for.
     * @return string friendly url for the entry point id
     */
    static getFriendlyUrlSegmentForEntryPoint(entryPoint: string, entryPointType: EnvironmentModuleEntryPointType, fallbackToUnfriendlySegment?: boolean): string;
    /**
     * Gets a friendly url segment for an entry point
     * @param urlSegment the url segment.
     * @param entryPointType the type of entry point to look for.
     * @return string friendly url for the entry point
     */
    static getEntryPointFromFriendlyUrlSegment(urlSegment: string, entryPointType: EnvironmentModuleEntryPointType): string;
    /**
     * Gets the connection type information.
     *
     * @param typeName the type name.
     * @return EnvironmentConnectionTypeInfo the connection type information.
     */
    static getConnectionTypeInfo(typeName: string): EnvironmentConnectionTypeInfo;
    private static createConnectionMap;
    /**
     * splits an entrypoint identifier string into its respective module and entrypoint names
     * @param format the formatted entrypoint identifier string
     */
    static splitFormattedEntrypoint(format: string): {
        moduleName: string;
        entrypointName: string;
    };
    /**
     * creates a formatted entrypoint identifier string from an entrypoint
     * @param entryPoint the entrypoint to create the string from
     */
    static createFormattedEntrypoint(entryPoint: EnvironmentModuleEntryPoint): string;
    static createEntrypointId(moduleName: string, entryPointName: string): string;
    /**
     * Create a formatted iframe ID used to link iframes and their html element
     * Replace . with - because . is not permitted in css selectors required for testing
     * @param parentModuleName the name of the parent module of the iframe content
     * @param entryPointName the name of the entry point loaded by the iframe
     */
    static createFormattedIFrameId(parentModuleName: string, entryPointName: string): string;
    /**
     * splits an extension target identifier string into its respective module and extension target names
     * @param format the formatted extension target identifier string
     */
    static splitFormattedExtensionTarget(format: string): {
        moduleName: string;
        extensionTargetName: string;
    };
    /**
     * creates a formatted extension target identifier string from an extension target
     * @param entryPoint the extension target to create the string from
     */
    static createFormattedExtensionTarget(extensionTarget: ExtensionTarget): string;
    /**
     * resolves an entrypoint from a formatted entrypoint identifier string
     * @param formattedEntrypointIdentifier the formatted entrypoint identifier string
     */
    static resolveEntrypoint(formattedEntrypointIdentifier: string): EnvironmentModuleEntryPoint;
    /**
     * Gets the name of current shell or module.
     */
    static getModuleName(): string;
    /**
     * Gets the version of current shell or module.
     */
    static getModuleVersion(): string;
    /**
     * Compare the shell version with specified version.
     * - this function must be called after NavigationService Init was called, otherwise it
     * cannot get current shell version and return false.
     * - Tag format is expected be like "<Major>.<Minor>.<Patch>-<Tag>.<Tag version>".
     *   ex) 1.2.3-myTagName.123
     *
     * @param inputVersion the version to compare.
     * @return true if shell has newer version running.
     */
    static shellGreaterOrEqual(inputVersion: string): boolean;
    /**
     * Check if the gateway uses API set of version 2.0.0.
     * @returns true if version 2.0.0
     */
    static get isGatewayV200(): boolean;
    /**
     * check if the gateway runs on Windows platform.
     * @returns true if Windows platform.
     */
    static get isGatewayWindows(): boolean;
    /**
     * Check if the gateway runs on Linux platform.
     * @returns true if Linux platform.
     */
    static get isGatewayLinux(): boolean;
}