import * as internal from "../sdk/internal";
export import StructureVersionInfo = internal.StructureVersionInfo;
export declare namespace projects {
    class DependencyInAppStatus extends internal.AbstractEnum {
        static Available: DependencyInAppStatus;
        static Unavailable: DependencyInAppStatus;
        static WrongVersion: DependencyInAppStatus;
        protected qualifiedTsTypeName: string;
    }
    class ExportLevel extends internal.AbstractEnum {
        static Hidden: ExportLevel;
        static API: ExportLevel;
        protected qualifiedTsTypeName: string;
    }
    class ModuleExportLevel extends internal.AbstractEnum {
        static Source: ModuleExportLevel;
        static Protected: ModuleExportLevel;
        protected qualifiedTsTypeName: string;
    }
    class ProtectedModuleType extends internal.AbstractEnum {
        static AddOn: ProtectedModuleType;
        static Solution: ProtectedModuleType;
        protected qualifiedTsTypeName: string;
    }
    class SetupShortcutType extends internal.AbstractEnum {
        static Document: SetupShortcutType;
        static Folder: SetupShortcutType;
        protected qualifiedTsTypeName: string;
    }
    /**
     * Interfaces and instance classes for types from the Mendix sub meta model `Projects`.
     */
    /**
     * In version 11.12.0: introduced
     */
    class Dependency extends internal.Element<IModel> {
        static structureTypeName: string;
        static versionInfo: StructureVersionInfo;
        get containerAsModuleDependencies(): ModuleDependencies;
        get name(): string;
        set name(newValue: string);
        get minimumVersion(): string;
        set minimumVersion(newValue: string);
        get maximumVersion(): string;
        set maximumVersion(newValue: string);
        get inAppStatus(): DependencyInAppStatus;
        set inAppStatus(newValue: DependencyInAppStatus);
        constructor(model: internal.AbstractModel, structureTypeName: string, id: string, isPartial: boolean, unit: internal.ModelUnit, container: internal.AbstractElement);
        /**
         * Creates and returns a new Dependency instance in the SDK and on the server.
         * The new Dependency will be automatically stored in the 'mendix' property
         * of the parent ModuleDependencies element passed as argument.
         *
         * Warning! Can only be used on models with the following Mendix meta model versions:
         *  11.12.0 and higher
         */
        static createIn(container: ModuleDependencies): Dependency;
        /**
         * Creates and returns a new Dependency instance in the SDK and on the server.
         * Expects one argument: the IModel object the instance will "live on".
         * After creation, assign or add this instance to a property that accepts this kind of objects.
         */
        static create(model: IModel): Dependency;
    }
    interface IModuleDocument extends internal.IModelUnit {
        readonly model: IModel;
        readonly containerAsFolderBase: IFolderBase;
        readonly containerAsModule: IModule;
        asLoaded(): ModuleDocument;
        load(callback: (element: ModuleDocument) => void, forceRefresh?: boolean): void;
        load(forceRefresh?: boolean): Promise<ModuleDocument>;
    }
    abstract class ModuleDocument extends internal.ModelUnit<IModel> implements IModuleDocument {
        static structureTypeName: string;
        static versionInfo: StructureVersionInfo;
        get containerAsFolderBase(): FolderBase;
        get containerAsModule(): Module;
        constructor(model: internal.AbstractModel, structureTypeName: string, id: string, isPartial: boolean, container: IFolderBase | IModule);
    }
    interface IDocument extends IModuleDocument, internal.IByNameReferrable {
        readonly model: IModel;
        readonly containerAsFolderBase: IFolderBase;
        readonly name: string;
        /**
         * In version 9.10.0: added public
         */
        readonly documentation: string;
        /**
         * In version 9.11.0: added public
         */
        readonly excluded: boolean;
        asLoaded(): Document;
        load(callback: (element: Document) => void, forceRefresh?: boolean): void;
        load(forceRefresh?: boolean): Promise<Document>;
    }
    abstract class Document extends ModuleDocument implements IDocument {
        static structureTypeName: string;
        static versionInfo: StructureVersionInfo;
        get containerAsFolderBase(): FolderBase;
        get name(): string;
        set name(newValue: string);
        /**
         * In version 9.10.0: added public
         */
        get documentation(): string;
        set documentation(newValue: string);
        /**
         * In version 9.11.0: added public
         */
        get excluded(): boolean;
        set excluded(newValue: boolean);
        /**
         * In version 9.3.0: introduced
         */
        get exportLevel(): ExportLevel;
        set exportLevel(newValue: ExportLevel);
        constructor(model: internal.AbstractModel, structureTypeName: string, id: string, isPartial: boolean, container: IFolderBase);
        get qualifiedName(): string | null;
    }
    interface IFolderBase extends internal.IStructuralUnit {
        readonly model: IModel;
        readonly containerAsFolderBase: IFolderBase;
        readonly containerAsProject: IProject;
        folders: internal.IList<IFolder>;
        documents: internal.IList<IDocument>;
    }
    abstract class FolderBase extends internal.StructuralUnit<IModel> implements IFolderBase {
        static structureTypeName: string;
        static versionInfo: StructureVersionInfo;
        get containerAsFolderBase(): FolderBase;
        get containerAsProject(): Project;
        get folders(): internal.IList<IFolder>;
        get documents(): internal.IList<IDocument>;
        constructor(model: internal.AbstractModel, structureTypeName: string, id: string, isPartial: boolean, container: IFolderBase | IProject);
    }
    /**
     * See: {@link https://docs.mendix.com/refguide/resources relevant section in reference guide}
     */
    interface IFolder extends IFolderBase {
        readonly model: IModel;
        readonly containerAsFolderBase: IFolderBase;
        name: string;
    }
    /**
     * See: {@link https://docs.mendix.com/refguide/resources relevant section in reference guide}
     */
    class Folder extends FolderBase implements IFolder {
        static structureTypeName: string;
        static versionInfo: StructureVersionInfo;
        get containerAsFolderBase(): FolderBase;
        get name(): string;
        set name(newValue: string);
        constructor(model: internal.AbstractModel, structureTypeName: string, id: string, isPartial: boolean, container: IFolderBase);
        /**
         * Creates a new Folder unit in the SDK and on the server.
         * Expects one argument, the IFolderBase in which this unit is contained.
         */
        static createIn(container: IFolderBase): Folder;
    }
    /**
     * In version 11.12.0: introduced
     */
    class GuidMappingEntry extends internal.Element<IModel> {
        static structureTypeName: string;
        static versionInfo: StructureVersionInfo;
        get containerAsModuleGuidMapping(): ModuleGuidMapping;
        get packageGuid(): string;
        set packageGuid(newValue: string);
        get appGuid(): string;
        set appGuid(newValue: string);
        constructor(model: internal.AbstractModel, structureTypeName: string, id: string, isPartial: boolean, unit: internal.ModelUnit, container: internal.AbstractElement);
        /**
         * Creates and returns a new GuidMappingEntry instance in the SDK and on the server.
         * The new GuidMappingEntry will be automatically stored in the 'entries' property
         * of the parent ModuleGuidMapping element passed as argument.
         *
         * Warning! Can only be used on models with the following Mendix meta model versions:
         *  11.12.0 and higher
         */
        static createIn(container: ModuleGuidMapping): GuidMappingEntry;
        /**
         * Creates and returns a new GuidMappingEntry instance in the SDK and on the server.
         * Expects one argument: the IModel object the instance will "live on".
         * After creation, assign or add this instance to a property that accepts this kind of objects.
         */
        static create(model: IModel): GuidMappingEntry;
    }
    /**
     * In version 10.12.0: removed experimental
     * In version 10.0.0: introduced
     */
    class JarDependency extends internal.Element<IModel> {
        static structureTypeName: string;
        static versionInfo: StructureVersionInfo;
        get containerAsModuleSettings(): ModuleSettings;
        get groupId(): string;
        set groupId(newValue: string);
        get artifactId(): string;
        set artifactId(newValue: string);
        get version(): string;
        set version(newValue: string);
        get isIncluded(): boolean;
        set isIncluded(newValue: boolean);
        /**
         * In version 10.12.0: introduced
         */
        get exclusions(): internal.IList<JarDependencyExclusion>;
        constructor(model: internal.AbstractModel, structureTypeName: string, id: string, isPartial: boolean, unit: internal.ModelUnit, container: internal.AbstractElement);
        /**
         * Creates and returns a new JarDependency instance in the SDK and on the server.
         * The new JarDependency will be automatically stored in the 'jarDependencies' property
         * of the parent ModuleSettings element passed as argument.
         *
         * Warning! Can only be used on models with the following Mendix meta model versions:
         *  10.0.0 and higher
         */
        static createIn(container: ModuleSettings): JarDependency;
        /**
         * Creates and returns a new JarDependency instance in the SDK and on the server.
         * Expects one argument: the IModel object the instance will "live on".
         * After creation, assign or add this instance to a property that accepts this kind of objects.
         */
        static create(model: IModel): JarDependency;
    }
    /**
     * In version 10.12.0: introduced
     */
    class JarDependencyExclusion extends internal.Element<IModel> {
        static structureTypeName: string;
        static versionInfo: StructureVersionInfo;
        get containerAsJarDependency(): JarDependency;
        get groupId(): string;
        set groupId(newValue: string);
        get artifactId(): string;
        set artifactId(newValue: string);
        constructor(model: internal.AbstractModel, structureTypeName: string, id: string, isPartial: boolean, unit: internal.ModelUnit, container: internal.AbstractElement);
        /**
         * Creates and returns a new JarDependencyExclusion instance in the SDK and on the server.
         * The new JarDependencyExclusion will be automatically stored in the 'exclusions' property
         * of the parent JarDependency element passed as argument.
         *
         * Warning! Can only be used on models with the following Mendix meta model versions:
         *  10.12.0 and higher
         */
        static createIn(container: JarDependency): JarDependencyExclusion;
        /**
         * Creates and returns a new JarDependencyExclusion instance in the SDK and on the server.
         * Expects one argument: the IModel object the instance will "live on".
         * After creation, assign or add this instance to a property that accepts this kind of objects.
         */
        static create(model: IModel): JarDependencyExclusion;
    }
    /**
     * See: {@link https://docs.mendix.com/refguide/modules relevant section in reference guide}
     */
    interface IModule extends IFolderBase {
        readonly model: IModel;
        readonly containerAsProject: IProject;
        /**
         * The index of where this Module appears in the project.
         * This property is <em>required</em>, and of type double.
         * Also, its value needs to be unique among its siblings (meaning, in code: <tt>containerAsProject.modules</tt>) in the project.
         * In other words: <tt>containerAsProject.modules.map(m => m.sortedIndex)</tt> (TS syntax) needs to be a list with unique values.
         */
        sortIndex: number;
        name: string;
        /**
         * This property is required and cannot be set to null.
         */
        domainModel: domainmodels.IDomainModel;
        /**
         * This property is required and cannot be set to null.
         *
         * In version 9.8.0: introduced
         */
        moduleSettings: IModuleSettings;
        /**
         * This property is required and cannot be set to null.
         */
        moduleSecurity: security.IModuleSecurity;
        fromAppStore: boolean;
        /**
         * In version 9.1.0: deleted
         * In version 8.5.0: introduced
         */
        isReusableComponent: boolean;
        appStoreGuid: string;
        appStoreVersionGuid: string;
        appStoreVersion: string;
        /**
         * In version 11.0.0: deleted
         * In version 8.13.0: introduced
         */
        appStorePackageId: number;
        /**
         * In version 11.0.0: introduced
         */
        appStorePackageIdString: string;
        /**
         * In version 9.8.0: deleted
         * In version 9.3.0: introduced
         */
        exportLevel: ModuleExportLevel;
        /**
         * In version 9.3.0: introduced
         */
        isThemeModule: boolean;
        /**
         * In version 11.16.0: introduced
         */
        setupSettings: ISetupSettings | null;
    }
    /**
     * See: {@link https://docs.mendix.com/refguide/modules relevant section in reference guide}
     */
    class Module extends FolderBase implements IModule {
        static structureTypeName: string;
        static versionInfo: StructureVersionInfo;
        get containerAsProject(): Project;
        /**
         * The index of where this Module appears in the project.
         * This property is <em>required</em>, and of type double.
         * Also, its value needs to be unique among its siblings (meaning, in code: <tt>containerAsProject.modules</tt>) in the project.
         * In other words: <tt>containerAsProject.modules.map(m => m.sortedIndex)</tt> (TS syntax) needs to be a list with unique values.
         */
        get sortIndex(): number;
        set sortIndex(newValue: number);
        get name(): string;
        set name(newValue: string);
        get domainModel(): domainmodels.IDomainModel;
        set domainModel(newValue: domainmodels.IDomainModel);
        /**
         * In version 9.8.0: introduced
         */
        get moduleSettings(): IModuleSettings;
        set moduleSettings(newValue: IModuleSettings);
        get moduleSecurity(): security.IModuleSecurity;
        set moduleSecurity(newValue: security.IModuleSecurity);
        get fromAppStore(): boolean;
        set fromAppStore(newValue: boolean);
        /**
         * In version 9.1.0: deleted
         * In version 8.5.0: introduced
         */
        get isReusableComponent(): boolean;
        set isReusableComponent(newValue: boolean);
        get appStoreGuid(): string;
        set appStoreGuid(newValue: string);
        get appStoreVersionGuid(): string;
        set appStoreVersionGuid(newValue: string);
        get appStoreVersion(): string;
        set appStoreVersion(newValue: string);
        /**
         * In version 11.0.0: deleted
         * In version 8.13.0: introduced
         */
        get appStorePackageId(): number;
        set appStorePackageId(newValue: number);
        /**
         * In version 11.0.0: introduced
         */
        get appStorePackageIdString(): string;
        set appStorePackageIdString(newValue: string);
        /**
         * In version 9.8.0: deleted
         * In version 9.3.0: introduced
         */
        get exportLevel(): ModuleExportLevel;
        set exportLevel(newValue: ModuleExportLevel);
        /**
         * In version 9.3.0: introduced
         */
        get isThemeModule(): boolean;
        set isThemeModule(newValue: boolean);
        /**
         * In version 11.16.0: introduced
         */
        get setupSettings(): ISetupSettings | null;
        set setupSettings(newValue: ISetupSettings | null);
        constructor(model: internal.AbstractModel, structureTypeName: string, id: string, isPartial: boolean, container: IProject);
        /**
         * Creates a new Module unit in the SDK and on the server.
         * Expects one argument, the IProject in which this unit is contained.
         */
        static createIn(container: IProject): Module;
    }
    /**
     * In version 11.12.0: introduced
     */
    class ModuleDependencies extends internal.Element<IModel> {
        static structureTypeName: string;
        static versionInfo: StructureVersionInfo;
        get containerAsModuleSettings(): ModuleSettings;
        get mendix(): internal.IList<Dependency>;
        constructor(model: internal.AbstractModel, structureTypeName: string, id: string, isPartial: boolean, unit: internal.ModelUnit, container: internal.AbstractElement);
        /**
         * Creates and returns a new ModuleDependencies instance in the SDK and on the server.
         * The new ModuleDependencies will be automatically stored in the 'moduleDependencies' property
         * of the parent ModuleSettings element passed as argument.
         *
         * Warning! Can only be used on models with the following Mendix meta model versions:
         *  11.12.0 and higher
         */
        static createIn(container: ModuleSettings): ModuleDependencies;
        /**
         * Creates and returns a new ModuleDependencies instance in the SDK and on the server.
         * Expects one argument: the IModel object the instance will "live on".
         * After creation, assign or add this instance to a property that accepts this kind of objects.
         */
        static create(model: IModel): ModuleDependencies;
    }
    /**
     * In version 11.12.0: introduced
     */
    interface IModuleGuidMapping extends internal.IModelUnit {
        readonly model: IModel;
        readonly containerAsProject: IProject;
        asLoaded(): ModuleGuidMapping;
        load(callback: (element: ModuleGuidMapping) => void, forceRefresh?: boolean): void;
        load(forceRefresh?: boolean): Promise<ModuleGuidMapping>;
    }
    /**
     * In version 11.12.0: introduced
     */
    class ModuleGuidMapping extends internal.ModelUnit<IModel> implements IModuleGuidMapping {
        static structureTypeName: string;
        static versionInfo: StructureVersionInfo;
        get containerAsProject(): Project;
        get importedModuleGuid(): string;
        set importedModuleGuid(newValue: string);
        get packageModuleGuid(): string;
        set packageModuleGuid(newValue: string);
        get entries(): internal.IList<GuidMappingEntry>;
        constructor(model: internal.AbstractModel, structureTypeName: string, id: string, isPartial: boolean, container: IProject);
        /**
         * Creates a new ModuleGuidMapping unit in the SDK and on the server.
         * Expects one argument, the IProject in which this unit is contained.
         */
        static createIn(container: IProject): ModuleGuidMapping;
    }
    /**
     * See: {@link https://docs.mendix.com/refguide/module-settings relevant section in reference guide}
     *
     * In version 9.8.0: introduced
     */
    interface IModuleSettings extends IModuleDocument {
        readonly model: IModel;
        readonly containerAsModule: IModule;
        asLoaded(): ModuleSettings;
        load(callback: (element: ModuleSettings) => void, forceRefresh?: boolean): void;
        load(forceRefresh?: boolean): Promise<ModuleSettings>;
    }
    /**
     * See: {@link https://docs.mendix.com/refguide/module-settings relevant section in reference guide}
     *
     * In version 9.8.0: introduced
     */
    class ModuleSettings extends ModuleDocument implements IModuleSettings {
        static structureTypeName: string;
        static versionInfo: StructureVersionInfo;
        get containerAsModule(): Module;
        get exportLevel(): ModuleExportLevel;
        set exportLevel(newValue: ModuleExportLevel);
        /**
         * In version 9.12.0: introduced
         */
        get protectedModuleType(): ProtectedModuleType;
        set protectedModuleType(newValue: ProtectedModuleType);
        get version(): string;
        set version(newValue: string);
        /**
         * In version 10.0.0: introduced
         */
        get solutionIdentifier(): string;
        set solutionIdentifier(newValue: string);
        /**
         * In version 10.10.0: introduced
         */
        get extensionName(): string;
        set extensionName(newValue: string);
        /**
         * In version 10.0.0: introduced
         */
        get jarDependencies(): internal.IList<JarDependency>;
        /**
         * In version 10.0.0: introduced
         */
        get basedOnVersion(): string;
        set basedOnVersion(newValue: string);
        /**
         * In version 11.12.0: introduced
         */
        get packageId(): string;
        set packageId(newValue: string);
        /**
         * In version 11.12.0: introduced
         */
        get originalPackageId(): string;
        set originalPackageId(newValue: string);
        /**
         * In version 11.12.0: introduced
         */
        get checksum(): string;
        set checksum(newValue: string);
        /**
         * In version 11.12.0: introduced
         */
        get convertedChecksum(): string;
        set convertedChecksum(newValue: string);
        /**
         * In version 11.12.0: introduced
         */
        get moduleDependencies(): ModuleDependencies | null;
        set moduleDependencies(newValue: ModuleDependencies | null);
        /**
         * In version 11.12.0: introduced
         */
        get enableDetailedTroubleshooting(): boolean;
        set enableDetailedTroubleshooting(newValue: boolean);
        constructor(model: internal.AbstractModel, structureTypeName: string, id: string, isPartial: boolean, container: IModule);
        /**
         * Creates a new ModuleSettings unit in the SDK and on the server.
         * Expects one argument, the IModule in which this unit is contained.
         */
        static createIn(container: IModule): ModuleSettings;
    }
    class OneTimeConversionMarker extends internal.Element<IModel> {
        static structureTypeName: string;
        static versionInfo: StructureVersionInfo;
        get containerAsProjectConversion(): ProjectConversion;
        get name(): string;
        set name(newValue: string);
        constructor(model: internal.AbstractModel, structureTypeName: string, id: string, isPartial: boolean, unit: internal.ModelUnit, container: internal.AbstractElement);
        /**
         * Creates and returns a new OneTimeConversionMarker instance in the SDK and on the server.
         * The new OneTimeConversionMarker will be automatically stored in the 'markers' property
         * of the parent ProjectConversion element passed as argument.
         */
        static createIn(container: ProjectConversion): OneTimeConversionMarker;
        /**
         * Creates and returns a new OneTimeConversionMarker instance in the SDK and on the server.
         * Expects one argument: the IModel object the instance will "live on".
         * After creation, assign or add this instance to a property that accepts this kind of objects.
         */
        static create(model: IModel): OneTimeConversionMarker;
    }
    /**
     * See: {@link https://docs.mendix.com/refguide/project relevant section in reference guide}
     */
    interface IProject extends internal.IStructuralUnit {
        readonly model: IModel;
        projectDocuments: internal.IList<IProjectDocument>;
        modules: internal.IList<IModule>;
        /**
         * This property is required and cannot be set to null.
         */
        projectConversion: IProjectConversion;
        isSystemProject: boolean;
        /**
         * In version 11.12.0: introduced
         */
        guidMappings: internal.IList<IModuleGuidMapping>;
    }
    /**
     * See: {@link https://docs.mendix.com/refguide/project relevant section in reference guide}
     */
    class Project extends internal.StructuralUnit<IModel> implements IProject {
        static structureTypeName: string;
        static versionInfo: StructureVersionInfo;
        get projectDocuments(): internal.IList<IProjectDocument>;
        get modules(): internal.IList<IModule>;
        get projectConversion(): IProjectConversion;
        set projectConversion(newValue: IProjectConversion);
        get isSystemProject(): boolean;
        set isSystemProject(newValue: boolean);
        /**
         * In version 11.12.0: introduced
         */
        get guidMappings(): internal.IList<IModuleGuidMapping>;
        constructor(model: internal.AbstractModel, structureTypeName: string, id: string, isPartial: boolean, container: internal.IStructuralUnit);
    }
    interface IProjectConversion extends internal.IModelUnit {
        readonly model: IModel;
        readonly containerAsProject: IProject;
        asLoaded(): ProjectConversion;
        load(callback: (element: ProjectConversion) => void, forceRefresh?: boolean): void;
        load(forceRefresh?: boolean): Promise<ProjectConversion>;
    }
    class ProjectConversion extends internal.ModelUnit<IModel> implements IProjectConversion {
        static structureTypeName: string;
        static versionInfo: StructureVersionInfo;
        get containerAsProject(): Project;
        get markers(): internal.IList<OneTimeConversionMarker>;
        constructor(model: internal.AbstractModel, structureTypeName: string, id: string, isPartial: boolean, container: IProject);
        /**
         * Creates a new ProjectConversion unit in the SDK and on the server.
         * Expects one argument, the IProject in which this unit is contained.
         */
        static createIn(container: IProject): ProjectConversion;
    }
    /**
     * See: {@link https://docs.mendix.com/refguide/project relevant section in reference guide}
     */
    interface IProjectDocument extends internal.IModelUnit {
        readonly model: IModel;
        readonly containerAsProject: IProject;
        asLoaded(): ProjectDocument;
        load(callback: (element: ProjectDocument) => void, forceRefresh?: boolean): void;
        load(forceRefresh?: boolean): Promise<ProjectDocument>;
    }
    /**
     * See: {@link https://docs.mendix.com/refguide/project relevant section in reference guide}
     */
    abstract class ProjectDocument extends internal.ModelUnit<IModel> implements IProjectDocument {
        static structureTypeName: string;
        static versionInfo: StructureVersionInfo;
        get containerAsProject(): Project;
        constructor(model: internal.AbstractModel, structureTypeName: string, id: string, isPartial: boolean, container: IProject);
    }
    /**
     * In version 11.16.0: introduced
     */
    abstract class SetupItem extends internal.Element<IModel> {
        static structureTypeName: string;
        static versionInfo: StructureVersionInfo;
        get containerAsSetupFolder(): SetupFolder;
        get containerAsSetupSettings(): SetupSettings;
        constructor(model: internal.AbstractModel, structureTypeName: string, id: string, isPartial: boolean, unit: internal.ModelUnit, container: internal.AbstractElement);
    }
    /**
     * In version 11.16.0: introduced
     */
    class SetupFolder extends SetupItem {
        static structureTypeName: string;
        static versionInfo: StructureVersionInfo;
        get containerAsSetupFolder(): SetupFolder;
        get containerAsSetupSettings(): SetupSettings;
        get name(): string;
        set name(newValue: string);
        get items(): internal.IList<SetupItem>;
        constructor(model: internal.AbstractModel, structureTypeName: string, id: string, isPartial: boolean, unit: internal.ModelUnit, container: internal.AbstractElement);
        /**
         * Creates and returns a new SetupFolder instance in the SDK and on the server.
         * The new SetupFolder will be automatically stored in the 'items' property
         * of the parent SetupFolder element passed as argument.
         *
         * Warning! Can only be used on models with the following Mendix meta model versions:
         *  11.16.0 and higher
         */
        static createInSetupFolderUnderItems(container: SetupFolder): SetupFolder;
        /**
         * Creates and returns a new SetupFolder instance in the SDK and on the server.
         * The new SetupFolder will be automatically stored in the 'items' property
         * of the parent SetupSettings element passed as argument.
         *
         * Warning! Can only be used on models with the following Mendix meta model versions:
         *  11.16.0 and higher
         */
        static createInSetupSettingsUnderItems(container: SetupSettings): SetupFolder;
        /**
         * Creates and returns a new SetupFolder instance in the SDK and on the server.
         * Expects one argument: the IModel object the instance will "live on".
         * After creation, assign or add this instance to a property that accepts this kind of objects.
         */
        static create(model: IModel): SetupFolder;
    }
    /**
     * In version 11.16.0: introduced
     */
    interface ISetupSettings extends IModuleDocument {
        readonly model: IModel;
        readonly containerAsModule: IModule;
        asLoaded(): SetupSettings;
        load(callback: (element: SetupSettings) => void, forceRefresh?: boolean): void;
        load(forceRefresh?: boolean): Promise<SetupSettings>;
    }
    /**
     * In version 11.16.0: introduced
     */
    class SetupSettings extends ModuleDocument implements ISetupSettings {
        static structureTypeName: string;
        static versionInfo: StructureVersionInfo;
        get containerAsModule(): Module;
        get items(): internal.IList<SetupItem>;
        constructor(model: internal.AbstractModel, structureTypeName: string, id: string, isPartial: boolean, container: IModule);
        /**
         * Creates a new SetupSettings unit in the SDK and on the server.
         * Expects one argument, the IModule in which this unit is contained.
         */
        static createIn(container: IModule): SetupSettings;
    }
    /**
     * In version 11.16.0: introduced
     */
    class SetupShortcut extends SetupItem {
        static structureTypeName: string;
        static versionInfo: StructureVersionInfo;
        get containerAsSetupFolder(): SetupFolder;
        get containerAsSetupSettings(): SetupSettings;
        get targetDocumentFullName(): string;
        set targetDocumentFullName(newValue: string);
        get targetGuid(): string;
        set targetGuid(newValue: string);
        get shortcutType(): SetupShortcutType;
        set shortcutType(newValue: SetupShortcutType);
        constructor(model: internal.AbstractModel, structureTypeName: string, id: string, isPartial: boolean, unit: internal.ModelUnit, container: internal.AbstractElement);
        /**
         * Creates and returns a new SetupShortcut instance in the SDK and on the server.
         * The new SetupShortcut will be automatically stored in the 'items' property
         * of the parent SetupFolder element passed as argument.
         *
         * Warning! Can only be used on models with the following Mendix meta model versions:
         *  11.16.0 and higher
         */
        static createInSetupFolderUnderItems(container: SetupFolder): SetupShortcut;
        /**
         * Creates and returns a new SetupShortcut instance in the SDK and on the server.
         * The new SetupShortcut will be automatically stored in the 'items' property
         * of the parent SetupSettings element passed as argument.
         *
         * Warning! Can only be used on models with the following Mendix meta model versions:
         *  11.16.0 and higher
         */
        static createInSetupSettingsUnderItems(container: SetupSettings): SetupShortcut;
        /**
         * Creates and returns a new SetupShortcut instance in the SDK and on the server.
         * Expects one argument: the IModel object the instance will "live on".
         * After creation, assign or add this instance to a property that accepts this kind of objects.
         */
        static create(model: IModel): SetupShortcut;
    }
}
import { domainmodels } from "./domainmodels";
import { security } from "./security";
import { IModel } from "./base-model";