@lowcodeunit/applications-flow-common 1.33.69-angular-13 → 1.33.71-lets-get-social-ish

package/esm2015/lib/services/project.service.js

@@ -0,0 +1,321 @@
+import { __awaiter } from "tslib";
+import { Injectable } from '@angular/core';
+import { ApplicationsFlowService } from './applications-flow.service';
+import * as i0 from "@angular/core";
+import * as i1 from "./applications-flow.service";
+export class ProjectService {
+    constructor(appsFlowSvc) {
+        this.appsFlowSvc = appsFlowSvc;
+    }
+    // public CreateRepository(state: ApplicationsFlowState, org: string, repoName: string): void {
+    //   state.GitHub.Loading = true;
+    //   this.appsFlowSvc
+    //     .CreateRepository(org, repoName)
+    //     .subscribe((response: BaseResponse) => {
+    //       if (response.Status.Code === 0) {
+    //         this.listRepositories(repoName);
+    //         state.GitHub.CreatingRepository = false;
+    //       } else {
+    //         //  TODO:  Need to surface an error to the user...
+    //         state.GitHub.Loading = false;
+    //       }
+    //     });
+    // }
+    DeleteApplication(state, appLookup) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve, reject) => {
+                state.Loading = true;
+                this.appsFlowSvc.DeleteApplication(appLookup).subscribe((response) => __awaiter(this, void 0, void 0, function* () {
+                    if (response.Status.Code === 0) {
+                        const eac = yield this.LoadEnterpriseAsCode(state);
+                        resolve(eac);
+                    }
+                    else {
+                        state.Loading = false;
+                        reject(response.Status);
+                        console.log(response);
+                    }
+                }), (err) => {
+                    state.Loading = false;
+                    reject(err);
+                    console.log(err);
+                });
+            });
+        });
+    }
+    DeleteDevOpsAction(state, doaLookup) {
+        return new Promise((resolve, reject) => {
+            state.Loading = true;
+            this.appsFlowSvc.DeleteDevOpsAction(doaLookup).subscribe((response) => __awaiter(this, void 0, void 0, function* () {
+                if (response.Status.Code === 0) {
+                    const eac = yield this.LoadEnterpriseAsCode(state);
+                    resolve(eac);
+                }
+                else {
+                    state.Loading = false;
+                    reject(response.Status);
+                    console.log(response);
+                }
+            }), (err) => {
+                state.Loading = false;
+                reject(err);
+                console.log(err);
+            });
+        });
+    }
+    DeleteProject(state, projectLookup) {
+        return new Promise((resolve, reject) => {
+            state.Loading = true;
+            this.appsFlowSvc.DeleteProject(projectLookup).subscribe((response) => __awaiter(this, void 0, void 0, function* () {
+                if (response.Status.Code === 0) {
+                    const eac = yield this.LoadEnterpriseAsCode(state);
+                    resolve(eac);
+                }
+                else {
+                    state.Loading = false;
+                    reject(response.Status);
+                    console.log(response);
+                }
+            }), (err) => {
+                state.Loading = false;
+                reject(err);
+                console.log(err);
+            });
+        });
+    }
+    DeleteSourceControl(state, scLookup) {
+        return new Promise((resolve, reject) => {
+            state.Loading = true;
+            this.appsFlowSvc.DeleteSourceControl(scLookup).subscribe((response) => __awaiter(this, void 0, void 0, function* () {
+                if (response.Status.Code === 0) {
+                    const eac = yield this.LoadEnterpriseAsCode(state);
+                    resolve(eac);
+                }
+                else {
+                    state.Loading = false;
+                    reject(response.Status);
+                    console.log(response);
+                }
+            }), (err) => {
+                state.Loading = false;
+                reject(err);
+                console.log(err);
+            });
+        });
+    }
+    EnsureUserEnterprise(state) {
+        return new Promise((resolve, reject) => {
+            state.Loading = true;
+            this.appsFlowSvc.EnsureUserEnterprise().subscribe((response) => __awaiter(this, void 0, void 0, function* () {
+                if (response.Status.Code === 0) {
+                    const eac = yield this.LoadEnterpriseAsCode(state);
+                    resolve(eac);
+                }
+                else {
+                    state.Loading = false;
+                    reject(response.Status);
+                    console.log(response);
+                }
+            }), (err) => {
+                state.Loading = false;
+                reject(err);
+                console.log(err);
+            });
+        });
+    }
+    GetActiveEnterprise(state) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve, reject) => {
+                state.Loading = true;
+                this.appsFlowSvc.GetActiveEnterprise().subscribe((response) => __awaiter(this, void 0, void 0, function* () {
+                    var _a;
+                    if (response.Status.Code === 0) {
+                        state.ActiveEnterpriseLookup = (_a = response.Model) === null || _a === void 0 ? void 0 : _a.Lookup;
+                        state.Loading = false;
+                        resolve();
+                    }
+                    else {
+                        state.Loading = false;
+                        reject(response.Status);
+                        console.log(response);
+                    }
+                }), (err) => {
+                    state.Loading = false;
+                    reject(err);
+                    console.log(err);
+                });
+            });
+        });
+    }
+    HasValidConnection(state, forceEnsureUser = false) {
+        return new Promise((resolve, reject) => {
+            state.Loading = true;
+            this.appsFlowSvc.HasValidConnection().subscribe((response) => __awaiter(this, void 0, void 0, function* () {
+                state.GitHub.HasConnection = response.Status.Code === 0;
+                if (state.GitHub.HasConnection || forceEnsureUser) {
+                    const eac = yield this.EnsureUserEnterprise(state);
+                    resolve(eac);
+                }
+                else {
+                    state.Loading = false;
+                    resolve({});
+                }
+            }), (err) => {
+                state.Loading = false;
+                reject(err);
+                console.log(err);
+            });
+        });
+    }
+    ListEnterprises(state) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve, reject) => {
+                state.Loading = true;
+                this.appsFlowSvc.ListEnterprises().subscribe((response) => __awaiter(this, void 0, void 0, function* () {
+                    state.Loading = false;
+                    if (response.Status.Code === 0) {
+                        state.Enterprises = response.Model;
+                        resolve(response.Model);
+                    }
+                    else {
+                        reject(response.Status);
+                        console.log(response);
+                    }
+                }), (err) => {
+                    state.Loading = false;
+                    reject(err);
+                    console.log(err);
+                });
+            });
+        });
+    }
+    LoadEnterpriseAsCode(state) {
+        return new Promise((resolve, reject) => {
+            state.Loading = true;
+            this.appsFlowSvc.LoadEnterpriseAsCode().subscribe((response) => {
+                var _a;
+                state.Loading = false;
+                if (response.Status.Code === 0) {
+                    state.EaC = response.Model || {};
+                }
+                else if (response.Status.Code === 3) {
+                }
+                state.EaC = state.EaC || {};
+                this.CreatingProject =
+                    Object.keys(((_a = state === null || state === void 0 ? void 0 : state.EaC) === null || _a === void 0 ? void 0 : _a.Projects) || {}).length <= 0;
+                if (this.CreatingProject) {
+                    window.location.href = '/dashboard/create-project';
+                }
+                resolve(state.EaC);
+                console.log(state);
+            }, (err) => {
+                state.Loading = false;
+                reject(err);
+                console.log(err);
+            });
+        });
+    }
+    SetActiveEnterprise(state, activeEntLookup) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve, reject) => {
+                state.Loading = true;
+                this.appsFlowSvc.SetActiveEnterprise(activeEntLookup).subscribe((response) => __awaiter(this, void 0, void 0, function* () {
+                    if (response.Status.Code === 0) {
+                        this.EditingProjectLookup = null;
+                        state.ActiveEnterpriseLookup = activeEntLookup;
+                        const eac = yield this.LoadEnterpriseAsCode(state);
+                        resolve(eac);
+                    }
+                    else {
+                        state.Loading = false;
+                        reject(response.Status);
+                        console.log(response);
+                    }
+                }), (err) => {
+                    state.Loading = false;
+                    reject(err);
+                    console.log(err);
+                });
+            });
+        });
+    }
+    SaveEnterpriseAsCode(state, eac) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve, reject) => {
+                state.Loading = true;
+                this.appsFlowSvc.SaveEnterpriseAsCode(eac).subscribe((response) => __awaiter(this, void 0, void 0, function* () {
+                    if (response.Status.Code === 0) {
+                        eac = yield this.LoadEnterpriseAsCode(state);
+                        resolve(eac);
+                    }
+                    else {
+                        state.Loading = false;
+                        reject(response.Status);
+                        console.log(response);
+                    }
+                }), (err) => {
+                    state.Loading = false;
+                    reject(err);
+                    console.log(err);
+                });
+            });
+        });
+    }
+    SetCreatingProject(creatingProject) {
+        this.CreatingProject = creatingProject;
+        this.EditingProjectLookup = null;
+    }
+    SetEditProjectSettings(state, projectLookup) {
+        return new Promise((resolve, reject) => {
+            if (projectLookup != null) {
+                state.Loading = false;
+                this.EditingProjectLookup = null;
+                setTimeout(() => {
+                    this.EditingProjectLookup = projectLookup;
+                    resolve({});
+                }, 0);
+                this.CreatingProject = false;
+                console.log(state);
+            }
+            else {
+                state.Loading = false;
+                this.EditingProjectLookup = projectLookup;
+                this.CreatingProject = false;
+                resolve({});
+            }
+        });
+    }
+    ToggleCreateProject() {
+        this.SetCreatingProject(!this.CreatingProject);
+    }
+    UnpackLowCodeUnit(state, req) {
+        return new Promise((resolve, reject) => {
+            state.Loading = true;
+            this.appsFlowSvc.UnpackLowCodeUnit(req).subscribe((response) => __awaiter(this, void 0, void 0, function* () {
+                if (response.Status.Code === 0) {
+                    const eac = yield this.LoadEnterpriseAsCode(state);
+                    resolve(eac);
+                }
+                else {
+                    state.Loading = false;
+                    reject(response.Status);
+                    console.log(response);
+                }
+            }), (err) => {
+                state.Loading = false;
+                reject(err);
+                console.log(err);
+            });
+        });
+    }
+}
+ProjectService.ɵprov = i0.ɵɵdefineInjectable({ factory: function ProjectService_Factory() { return new ProjectService(i0.ɵɵinject(i1.ApplicationsFlowService)); }, token: ProjectService, providedIn: "root" });
+ProjectService.decorators = [
+    { type: Injectable, args: [{
+                providedIn: 'root',
+            },] }
+];
+ProjectService.ctorParameters = () => [
+    { type: ApplicationsFlowService }
+];
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"project.service.js","sourceRoot":"/home/runner/work/applications-flow/applications-flow/projects/common/src/","sources":["lib/services/project.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport { BaseModeledResponse, BaseResponse } from '@lcu/common';\nimport { debug } from 'console';\nimport { EaCProjectAsCode, EnterpriseAsCode } from '@semanticjs/common';\nimport {\n  ApplicationsFlowState,\n  GitHubWorkflowRun,\n  UnpackLowCodeUnitRequest,\n} from '../state/applications-flow.state';\nimport { ApplicationsFlowService } from './applications-flow.service';\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class ProjectService {\n  public CreatingProject: boolean;\n\n  public EditingProjectLookup: string;\n\n  constructor(protected appsFlowSvc: ApplicationsFlowService) {}\n\n  // public CreateRepository(state: ApplicationsFlowState, org: string, repoName: string): void {\n  //   state.GitHub.Loading = true;\n\n  //   this.appsFlowSvc\n  //     .CreateRepository(org, repoName)\n  //     .subscribe((response: BaseResponse) => {\n  //       if (response.Status.Code === 0) {\n  //         this.listRepositories(repoName);\n\n  //         state.GitHub.CreatingRepository = false;\n  //       } else {\n  //         //  TODO:  Need to surface an error to the user...\n\n  //         state.GitHub.Loading = false;\n  //       }\n  //     });\n  // }\n\n  public async DeleteApplication(\n    state: ApplicationsFlowState,\n    appLookup: string\n  ): Promise<EnterpriseAsCode> {\n    return new Promise((resolve, reject) => {\n      state.Loading = true;\n\n      this.appsFlowSvc.DeleteApplication(appLookup).subscribe(\n        async (response: BaseResponse) => {\n          if (response.Status.Code === 0) {\n            const eac = await this.LoadEnterpriseAsCode(state);\n\n            resolve(eac);\n          } else {\n            state.Loading = false;\n\n            reject(response.Status);\n\n            console.log(response);\n          }\n        },\n        (err) => {\n          state.Loading = false;\n\n          reject(err);\n\n          console.log(err);\n        }\n      );\n    });\n  }\n\n  public DeleteDevOpsAction(\n    state: ApplicationsFlowState,\n    doaLookup: string\n  ): Promise<EnterpriseAsCode> {\n    return new Promise((resolve, reject) => {\n      state.Loading = true;\n\n      this.appsFlowSvc.DeleteDevOpsAction(doaLookup).subscribe(\n        async (response: BaseResponse) => {\n          if (response.Status.Code === 0) {\n            const eac = await this.LoadEnterpriseAsCode(state);\n\n            resolve(eac);\n          } else {\n            state.Loading = false;\n\n            reject(response.Status);\n\n            console.log(response);\n          }\n        },\n        (err) => {\n          state.Loading = false;\n\n          reject(err);\n\n          console.log(err);\n        }\n      );\n    });\n  }\n\n  public DeleteProject(\n    state: ApplicationsFlowState,\n    projectLookup: string\n  ): Promise<EnterpriseAsCode> {\n    return new Promise((resolve, reject) => {\n      state.Loading = true;\n\n      this.appsFlowSvc.DeleteProject(projectLookup).subscribe(\n        async (response: BaseResponse) => {\n          if (response.Status.Code === 0) {\n            const eac = await this.LoadEnterpriseAsCode(state);\n\n            resolve(eac);\n          } else {\n            state.Loading = false;\n\n            reject(response.Status);\n\n            console.log(response);\n          }\n        },\n        (err) => {\n          state.Loading = false;\n\n          reject(err);\n\n          console.log(err);\n        }\n      );\n    });\n  }\n\n  public DeleteSourceControl(\n    state: ApplicationsFlowState,\n    scLookup: string\n  ): Promise<EnterpriseAsCode> {\n    return new Promise((resolve, reject) => {\n      state.Loading = true;\n\n      this.appsFlowSvc.DeleteSourceControl(scLookup).subscribe(\n        async (response: BaseResponse) => {\n          if (response.Status.Code === 0) {\n            const eac = await this.LoadEnterpriseAsCode(state);\n\n            resolve(eac);\n          } else {\n            state.Loading = false;\n\n            reject(response.Status);\n\n            console.log(response);\n          }\n        },\n        (err) => {\n          state.Loading = false;\n\n          reject(err);\n\n          console.log(err);\n        }\n      );\n    });\n  }\n\n  public EnsureUserEnterprise(\n    state: ApplicationsFlowState\n  ): Promise<EnterpriseAsCode> {\n    return new Promise((resolve, reject) => {\n      state.Loading = true;\n\n      this.appsFlowSvc.EnsureUserEnterprise().subscribe(\n        async (response: BaseResponse) => {\n          if (response.Status.Code === 0) {\n            const eac = await this.LoadEnterpriseAsCode(state);\n\n            resolve(eac);\n          } else {\n            state.Loading = false;\n\n            reject(response.Status);\n\n            console.log(response);\n          }\n        },\n        (err) => {\n          state.Loading = false;\n\n          reject(err);\n\n          console.log(err);\n        }\n      );\n    });\n  }\n\n  public async GetActiveEnterprise(\n    state: ApplicationsFlowState\n  ): Promise<void> {\n    return new Promise((resolve, reject) => {\n      state.Loading = true;\n\n      this.appsFlowSvc.GetActiveEnterprise().subscribe(\n        async (\n          response: BaseModeledResponse<{ Name: string; Lookup: string }>\n        ) => {\n          if (response.Status.Code === 0) {\n            state.ActiveEnterpriseLookup = response.Model?.Lookup;\n\n            state.Loading = false;\n\n            resolve();\n          } else {\n            state.Loading = false;\n\n            reject(response.Status);\n\n            console.log(response);\n          }\n        },\n        (err) => {\n          state.Loading = false;\n\n          reject(err);\n\n          console.log(err);\n        }\n      );\n    });\n  }\n\n  public HasValidConnection(\n    state: ApplicationsFlowState,\n    forceEnsureUser: boolean = false\n  ): Promise<EnterpriseAsCode> {\n    return new Promise((resolve, reject) => {\n      state.Loading = true;\n\n      this.appsFlowSvc.HasValidConnection().subscribe(\n        async (response: BaseResponse) => {\n          state.GitHub.HasConnection = response.Status.Code === 0;\n\n          if (state.GitHub.HasConnection || forceEnsureUser) {\n            const eac = await this.EnsureUserEnterprise(state);\n\n            resolve(eac);\n          } else {\n            state.Loading = false;\n\n            resolve({});\n          }\n        },\n        (err) => {\n          state.Loading = false;\n\n          reject(err);\n\n          console.log(err);\n        }\n      );\n    });\n  }\n\n  public async ListEnterprises(state: ApplicationsFlowState): Promise<any[]> {\n    return new Promise((resolve, reject) => {\n      state.Loading = true;\n\n      this.appsFlowSvc.ListEnterprises().subscribe(\n        async (response: BaseModeledResponse<Array<any>>) => {\n          state.Loading = false;\n\n          if (response.Status.Code === 0) {\n            state.Enterprises = response.Model;\n\n            resolve(response.Model);\n          } else {\n            reject(response.Status);\n\n            console.log(response);\n          }\n        },\n        (err) => {\n          state.Loading = false;\n\n          reject(err);\n\n          console.log(err);\n        }\n      );\n    });\n  }\n\n  public LoadEnterpriseAsCode(\n    state: ApplicationsFlowState\n  ): Promise<EnterpriseAsCode> {\n    return new Promise((resolve, reject) => {\n      state.Loading = true;\n\n      this.appsFlowSvc.LoadEnterpriseAsCode().subscribe(\n        (response: BaseModeledResponse<EnterpriseAsCode>) => {\n          state.Loading = false;\n\n          if (response.Status.Code === 0) {\n            state.EaC = response.Model || {};\n          } else if (response.Status.Code === 3) {\n          }\n\n          state.EaC = state.EaC || {};\n\n          this.CreatingProject =\n            Object.keys(state?.EaC?.Projects || {}).length <= 0;\n\n          if (this.CreatingProject) {\n            window.location.href = '/dashboard/create-project';\n          }\n\n          resolve(state.EaC);\n\n          console.log(state);\n        },\n        (err) => {\n          state.Loading = false;\n\n          reject(err);\n\n          console.log(err);\n        }\n      );\n    });\n  }\n\n  public async SetActiveEnterprise(\n    state: ApplicationsFlowState,\n    activeEntLookup: string\n  ): Promise<EnterpriseAsCode> {\n    return new Promise((resolve, reject) => {\n      state.Loading = true;\n\n      this.appsFlowSvc.SetActiveEnterprise(activeEntLookup).subscribe(\n        async (response: BaseResponse) => {\n          if (response.Status.Code === 0) {\n            this.EditingProjectLookup = null;\n\n            state.ActiveEnterpriseLookup = activeEntLookup;\n\n            const eac = await this.LoadEnterpriseAsCode(state);\n\n            resolve(eac);\n          } else {\n            state.Loading = false;\n\n            reject(response.Status);\n\n            console.log(response);\n          }\n        },\n        (err) => {\n          state.Loading = false;\n\n          reject(err);\n\n          console.log(err);\n        }\n      );\n    });\n  }\n\n  public async SaveEnterpriseAsCode(\n    state: ApplicationsFlowState,\n    eac: EnterpriseAsCode\n  ): Promise<EnterpriseAsCode> {\n    return new Promise((resolve, reject) => {\n      state.Loading = true;\n\n      this.appsFlowSvc.SaveEnterpriseAsCode(eac).subscribe(\n        async (response: BaseModeledResponse<string>) => {\n          if (response.Status.Code === 0) {\n            eac = await this.LoadEnterpriseAsCode(state);\n\n            resolve(eac);\n          } else {\n            state.Loading = false;\n\n            reject(response.Status);\n\n            console.log(response);\n          }\n        },\n        (err) => {\n          state.Loading = false;\n\n          reject(err);\n\n          console.log(err);\n        }\n      );\n    });\n  }\n\n  public SetCreatingProject(creatingProject: boolean): void {\n    this.CreatingProject = creatingProject;\n\n    this.EditingProjectLookup = null;\n  }\n\n  public SetEditProjectSettings(\n    state: ApplicationsFlowState,\n    projectLookup: string\n  ): Promise<any> {\n    return new Promise((resolve, reject) => {\n      if (projectLookup != null) {\n        state.Loading = false;\n\n        this.EditingProjectLookup = null;\n\n        setTimeout(() => {\n          this.EditingProjectLookup = projectLookup;\n\n          resolve({});\n        }, 0);\n\n        this.CreatingProject = false;\n\n        console.log(state);\n      } else {\n        state.Loading = false;\n\n        this.EditingProjectLookup = projectLookup;\n\n        this.CreatingProject = false;\n\n        resolve({});\n      }\n    });\n  }\n\n  public ToggleCreateProject(): void {\n    this.SetCreatingProject(!this.CreatingProject);\n  }\n\n  public UnpackLowCodeUnit(\n    state: ApplicationsFlowState,\n    req: UnpackLowCodeUnitRequest\n  ): Promise<EnterpriseAsCode> {\n    return new Promise((resolve, reject) => {\n      state.Loading = true;\n\n      this.appsFlowSvc.UnpackLowCodeUnit(req).subscribe(\n        async (response: BaseResponse) => {\n          if (response.Status.Code === 0) {\n            const eac = await this.LoadEnterpriseAsCode(state);\n\n            resolve(eac);\n          } else {\n            state.Loading = false;\n\n            reject(response.Status);\n\n            console.log(response);\n          }\n        },\n        (err) => {\n          state.Loading = false;\n\n          reject(err);\n\n          console.log(err);\n        }\n      );\n    });\n  }\n}\n"]}

package/esm2015/lib/state/applications-flow-state.context.js

@@ -0,0 +1,37 @@
+import { Injectable, Injector } from '@angular/core';
+import { StateContext } from '@lcu/common';
+import * as i0 from "@angular/core";
+export class ApplicationsFlowStateContext extends StateContext {
+    // Constructors
+    constructor(injector) {
+        super(injector);
+        this.injector = injector;
+    }
+    // API Methods
+    AddApplication() {
+        this.Execute({
+            Arguments: {},
+            Type: 'AddApplication'
+        });
+    }
+    //  Helpers
+    defaultValue() {
+        return { Loading: true };
+    }
+    loadStateKey() {
+        return 'main';
+    }
+    loadStateName() {
+        return 'lcu';
+    }
+}
+ApplicationsFlowStateContext.ɵprov = i0.ɵɵdefineInjectable({ factory: function ApplicationsFlowStateContext_Factory() { return new ApplicationsFlowStateContext(i0.ɵɵinject(i0.INJECTOR)); }, token: ApplicationsFlowStateContext, providedIn: "root" });
+ApplicationsFlowStateContext.decorators = [
+    { type: Injectable, args: [{
+                providedIn: 'root'
+            },] }
+];
+ApplicationsFlowStateContext.ctorParameters = () => [
+    { type: Injector }
+];
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/state/applications-flow.state.js

@@ -0,0 +1,72 @@
+export class ApplicationsFlowState {
+    constructor() {
+        this.GitHub = {};
+        this.HostingDetails = {};
+        this.Loading = true;
+        // this.Projects = [];
+    }
+}
+// export class ProjectState {
+//   public ActionsSet?: { [id: string]: DevOpsAction };
+//   public Applications?: ApplicationState[];
+//   public Description?: string;
+//   public Host?: string;
+//   public ID?: string;
+//   public Image?: string;
+//   public LCUs?: GitHubLowCodeUnit[];
+//   public Name?: string;
+//   public PreventInheritedApplications?: boolean;
+//   public Runs?: GitHubWorkflowRun[];
+// }
+// export class ApplicationState {
+//   public IsPrivate?: boolean;
+//   public Name?: string;
+//   public Organization?: string;
+//   public PathRegex?: string;
+//   public Priority?: number;
+//   public Repository?: string;
+//   public Version?: string;
+// }
+export class GitHubSetupState {
+}
+export class GitHubBranch {
+}
+// export class GitHubLowCodeUnit {
+//   public Branch?: string;
+//   public ID?: string;
+//   public Lookup?: string;
+//   public Organization?: string;
+//   public Repository?: string;
+// }
+export class GitHubOrganization {
+}
+export class GitHubRepository {
+}
+export class GitHubWorkflowRun {
+}
+export class UnpackLowCodeUnitRequest {
+}
+// export class DevOpsAction {
+//   public Details?: string;
+//   public ID?: string;
+//   public Name?: string;
+//   public Overwrite?: boolean;
+//   public Path?: string;
+//   public Template?: string;
+// }
+export class ProjectHostingDetails {
+}
+export class ProjectHostingOption {
+}
+export class ProjectHostingOptionInput {
+}
+// export class EstablishProjectRequest {
+//   public Branch?: string;
+//   public BuildScript?: string;
+//   public HostingOption?: string;
+//   public Organization?: string;
+//   public OutputFolder?: string;
+//   public ProjectName?: string;
+//   public Repository?: string;
+// }
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lowcodeunit-applications-flow-common.js

@@ -0,0 +1,30 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './lcu.api';
+export { AnalyticsCardComponent as ɵt } from './lib/elements/analytics-card/analytics-card.component';
+export { BaseFormComponent as ɵk } from './lib/elements/base-form/base-form.component';
+export { CardCarouselComponent as ɵy } from './lib/elements/card-carousel/card-carousel.component';
+export { ColumnInfoCardComponent as ɵq } from './lib/elements/column-info-card/column-info-card.component';
+export { DynamicTabsComponent as ɵb } from './lib/elements/dynamic-tabs/dynamic-tabs.component';
+export { FeedCardSmComponent as ɵu } from './lib/elements/feed-card-sm/feed-card-sm.component';
+export { FormCardComponent as ɵj } from './lib/elements/form-card/form-card.component';
+export { GhControlComponent as ɵv } from './lib/elements/gh-control/gh-control.component';
+export { MainFeedCardComponent as ɵw } from './lib/elements/main-feed-card/main-feed-card.component';
+export { ProjectInfoCardComponent as ɵs } from './lib/elements/project-info-card/project-info-card.component';
+export { BuildsComponent as ɵh } from './lib/elements/projects/controls/builds/builds.component';
+export { HeaderComponent as ɵc } from './lib/elements/projects/controls/header/header.component';
+export { ProjectItemsComponent as ɵg } from './lib/elements/projects/controls/project-items/project-items.component';
+export { ProjectTabsComponent as ɵd } from './lib/elements/projects/controls/project-tabs/project-tabs.component';
+export { RecentActivitiesComponent as ɵi } from './lib/elements/projects/controls/recent-activities/recent-activities.component';
+export { AppsFlowComponent as ɵm } from './lib/elements/projects/controls/tabs/apps-flow/apps-flow.component';
+export { NpmPackageSelectComponent as ɵp } from './lib/elements/projects/controls/tabs/apps-flow/npm-package-select/npm-package-select.component';
+export { DevOpsComponent as ɵn } from './lib/elements/projects/controls/tabs/devops/devops.component';
+export { DFSModifiersComponent as ɵo } from './lib/elements/projects/controls/tabs/dfs-modifiers/dfs-modifiers.component';
+export { DomainsComponent as ɵf } from './lib/elements/projects/controls/tabs/domains/domains.component';
+export { BaseFormTestComponent as ɵl } from './lib/elements/projects/controls/tabs/general/forms/base-form-test/base-form-test.component';
+export { GeneralComponent as ɵe } from './lib/elements/projects/controls/tabs/general/general.component';
+export { SlottedCardComponent as ɵr } from './lib/elements/slotted-card/slotted-card.component';
+export { TwoColumnHeaderComponent as ɵx } from './lib/elements/two-column-header/two-column-header.component';
+export { ApplicationsFlowEventsService as ɵa } from './lib/services/applications-flow-events.service';
+//# sourceMappingURL=data:application/json;base64,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