@omnia/tooling-composers/internal-do-not-import-from-here/models/ServerManifests.d.ts

Provide tooling to work with manifest things.

import { ServerManifestTypes, RequestedResourceTypes } from "./Enums";
import { SecurityProviderTypes, SecurityRoleScopes, RuleLogicalOperator, ServiceTypes } from "./index";
import { IIcon } from '../../../fx-models/Icon';
import { ServiceParam } from '../../../fx-models/ServiceParam';
import { FeatureUIOption, IFeatureConfiguration } from '../../../fx-models/Feature';
import { GuidValue } from '../../../fx-models';
import { OmniaBackendRuntimes, OmniaRoleTypes, PersistentDiskTypes } from "../../../fx-models/Enums";
import { AzureAdAppPermissionInfo, AzureAdAppResourceAccessWithAlternate } from "../../../fx-models/AzureAdAppPermissions";
import { AzureAdAppPermissionOption } from "../AzureAdAppPermissionHelper";
export interface ServiceFeatureOption {
    /**
     * Title
     * Feature title
     * */
    title: string;
    /**
     * Description
     * Feature description
     * */
    description: string;
    /**
     * ConsentInformation
     * Feature consent information
     * */
    consentInformation?: string;
    /**
     * Version
     * Feature version
     * */
    version: string;
    /**
     * Icons
     * Array of supported icon formats, i.e. the same icon different formats
     * */
    icons: Array<IIcon>;
    /**
     * Category
     * Logical group of Feature
     * */
    category: string;
    /**
     * TargetResolverType
     * Server-side type used to resolve feature target based on the context parameters
     * */
    targetResolverType: string;
    /**
     * HasProviderHandling
     * Specify whether this feature needs to be handled with a Queue Message
     * */
    hasProviderHandling: boolean;
    /**
     * Parameters
     * Parameters required for activating/upgrading/deactivating features
     * (exclude parameters required to resolve target)
     * */
    parameters: Array<ServiceParam>;
    /**
     * PermissionRole
     * Permission Role required for activating/upgrading/deactivating feature
     * */
    permissionRole: GuidValue;
    /**
     * UIOptions
     * Optional - used to specify the client-side control which will display the wizard when activating/upgrading/deactivating feature
     * */
    uiOptions?: FeatureUIOption;
    /**
     * Hidden
     * Optional - used to specify whether the feature is hidden in the UI and only available to be activated from api
     * */
    hidden?: boolean;
    /**
    * requiresLicense
    * Optional - Specify license id(s) if the feature requires license to be activated
    * */
    requiresLicense?: Array<GuidValue>;
    /**
    * requiresBackendEnvironment
    * Optional - Specify Backend runtime evironment to be activated
    * */
    requiresBackendEnvironment?: OmniaBackendRuntimes[];
    /**
    *   Require an Azure Ad App permissions
    */
    requiresAzureAdAppPermissions?: AzureAdAppPermissionOption;
    /**
     * Feature configuration
     */
    configuration?: IFeatureConfiguration;
}
export interface OnTheFlyServiceRequest {
    serviceId: GuidValue;
}
export interface ServiceFeatureManifest extends Omit<ServiceFeatureOption, 'requiresAzureAdAppPermissions'>, ServerManifest {
    uniqueId: GuidValue;
    requiresAzureAdAppPermissions?: AzureAdAppPermissionInfo[];
    requestedResources?: RequestedResourceManifest[];
    requestedOnTheFlyServices?: OnTheFlyServiceRequest[];
}
export interface AppResourceType {
    id: GuidValue;
    title: string;
    icon: IIcon;
    parameters: Array<ServiceParam>;
    providedParameters: Array<ServiceParam>;
    requiredFeatures?: Array<GuidValue>;
    requiredEnvironments?: Array<string>;
}
export interface ServiceAppDefinitionOption {
    title: string;
    description: string;
    /**
     * Each app will connected to an Omnia Route
     *
     * An Omnia Route is combination between {Prefix} and {Alias}
     * e.g. /_/app-1 is combine between '_' as {Prefix} and 'app-1' as {Alias}
     *
     * */
    defaultRoutePrefix: string;
    icons: Array<IIcon>;
    version: string;
    /**
    * requiresLicense
    * Optional - Specify license id(s) if the app requires license
    * */
    requiresLicense?: Array<GuidValue>;
    /**
     * Hidden
     * Optional - used to specify whether the app is hidden in the UI and only available to be activated from api
     * */
    hidden?: boolean;
    /**
     * Define at least one resource type
     * */
    resourceTypes: AppResourceType[];
}
export interface ServiceAppDefinitionManifest extends ServiceAppDefinitionOption, ServerManifest {
    uniqueId: GuidValue;
}
export interface ServiceRoleDefinitionOption {
    name: string;
    permissionEvaluatorType?: string;
    resourceEvaluatorType?: string;
    roleType: OmniaRoleTypes;
    parameters?: ServiceParam[];
    parentRole?: GuidValue;
    rules?: SecurityRule[];
    editableRoles?: GuidValue[];
    systemDefinedRuleMappingRoles?: GuidValue[];
    isBindable?: boolean;
    isExtensionOnly?: boolean;
}
export interface ServiceRoleDefinitionManifest extends ServiceRoleDefinitionOption, ServerManifest {
    uniqueId: GuidValue;
}
export interface SecurityRule {
    roleId: GuidValue;
    logicalOperator: "OR" | "AND";
}
export interface RequestedResourceManifest extends ServerManifest {
    resourceType: RequestedResourceTypes;
}
export interface ResourceOptionBase {
    uniqueId: GuidValue;
}
export interface SqlResourceOption extends ResourceOptionBase {
}
export interface PersistentDiskResourceOption extends ResourceOptionBase {
    type?: PersistentDiskTypes;
}
export interface SqlElasticPoolResourceOption extends ResourceOptionBase {
    elasticPoolId: GuidValue;
}
export interface SqlResourceManifest extends SqlResourceOption, RequestedResourceManifest {
}
export interface SqlElasticPoolResourceManifest extends SqlElasticPoolResourceOption, RequestedResourceManifest {
}
export interface PeristentDiskResourceManifest extends PersistentDiskResourceOption, RequestedResourceManifest {
}
export interface ServerManifestByTypeCollection {
    [manifestType: string]: Array<ServerManifest>;
}
export interface ServerManifest {
    manifestType: ServerManifestTypes;
}
export interface SecurityProviderManifest extends ServerManifest {
    securityProviders: Array<SecurityProvider>;
}
export interface AzureAdAppPermissionManifest extends ServerManifest {
    name?: string;
    resourceAppId: GuidValue;
    resourceAccess: AzureAdAppResourceAccessWithAlternate[];
}
export interface AzureAdAppPermission {
    id: string;
    value: string;
}
export interface AzureAdAppApiPermission {
    uiName: string;
    appId: string;
    appRoles: {
        [value: string]: AzureAdAppPermission;
    };
    oauth2Permissions: {
        [value: string]: AzureAdAppPermission;
    };
}
export interface AzureAdAppPermissionInputWithAlternate {
    require: string;
    alternatePermissions?: string[];
}
export interface AzureAdAppPermissionInput {
    appPermissions?: string[];
    appPermissionsWithAlternate?: AzureAdAppPermissionInputWithAlternate[];
    delegatedPermissions?: string[];
    delegatedPermissionsWithAlternate?: AzureAdAppPermissionInputWithAlternate[];
}
export interface ServiceOptions {
    description?: string;
}
export interface ServiceBase extends ServiceOptions {
    id: string;
    title?: string;
    serviceType: ServiceTypes;
    optionalService: boolean;
    isOnTheFlyService?: boolean;
}
export interface CustomService extends ServiceBase {
    helmCommand?: string;
}
export interface ServiceManifest extends ServiceBase, ServerManifest {
}
export interface SecurityProviderIdentity {
    providerId: string;
}
export interface SecurityProvider extends SecurityProviderIdentity {
    type: SecurityProviderTypes;
}
export interface SecurityRoleIdentity {
    roleName: string;
    scope: SecurityRoleScopes;
}
export interface RoleBasedSecurityProviderOptions extends SecurityProviderIdentity, SecurityRoleIdentity {
}
export interface CombinedSecurityProviderOptions extends SecurityProviderIdentity {
}
export interface RoleBasedSecurityProvider extends RoleBasedSecurityProviderOptions, SecurityProvider {
}
export interface SecurityProviderRule extends SecurityProviderIdentity {
    logicalOperator: RuleLogicalOperator;
}
export interface CombinedSecurityProviders extends SecurityProvider {
    securityProviderRules: Array<SecurityProviderRule>;
}