@kumori/aurora-backend-handler 1.0.0

package/environment.ts

@@ -0,0 +1,7 @@
+export const environment = {
+    apiServer: {
+      baseUrl: '',
+      apiVersion: ''
+    }
+  };
+  

package/event-helper.ts

@@ -0,0 +1,577 @@
+import { Account, Environment, Link, MarketplaceItem, MarketplaceService, Organization, PlanProvider, Registry, Tenant, tenantRole, User, Service, Notification, Resource } from "@hestekumori/aurora-interfaces";
+import { EventNames } from "./event-names";
+export interface RegistryUpdatePayload {
+  tenant: Tenant;
+  registry: Registry;
+}
+export class EventHelper {
+  globalEventHandler: any;
+
+  constructor(eventHandler: any) {
+    this.globalEventHandler = eventHandler;
+  }
+
+  private createEvent<T>(eventName: string) {
+	if (!this.globalEventHandler) {
+	  console.error("globalEventHandler es undefined al crear el evento:", eventName);
+	}
+	return {
+	  publish: (data: T) => this.globalEventHandler.publish(eventName, data),
+	  subscribe: (callback: (payload: T) => void) => {
+		if (!this.globalEventHandler.subscribe) {
+		  console.error("subscribe no existe para", eventName);
+		}
+		return this.globalEventHandler.subscribe(eventName, callback);
+	  },
+	  unsubscribe: (callback: (payload: T) => void) =>
+		this.globalEventHandler.unsubscribe(eventName, callback),
+	};
+  }
+  
+
+  // * Tenant
+  get tenant() {
+    return {
+      publish: {
+        creation: this.createEvent<Tenant>(EventNames.CreateTenant).publish,
+        created: this.createEvent<Tenant>(EventNames.TenantCreated).publish,
+        creationError: this.createEvent<Tenant>(EventNames.TenantCreationError).publish,
+        update: this.createEvent<Tenant>(EventNames.UpdateTenant).publish,
+        updated: this.createEvent<Tenant>(EventNames.TenantUpdated).publish,
+        updateError: this.createEvent<Tenant>(EventNames.TenantUpdateError).publish,
+        delete: this.createEvent<Tenant>(EventNames.DeleteTenant).publish,
+        deleted: this.createEvent<Tenant>(EventNames.TenantDeleted).publish,
+        deletionError: this.createEvent<Tenant>(EventNames.TenantDeletionError).publish,
+        createRegistry: this.createEvent<RegistryUpdatePayload>(EventNames.CreateRegistry).publish,
+        registryCreated: this.createEvent<RegistryUpdatePayload>(EventNames.RegistryCreated).publish,
+        registryCreationError: this.createEvent<RegistryUpdatePayload>(EventNames.RegistryCreationError).publish,
+        updateRegistry: this.createEvent<RegistryUpdatePayload>(EventNames.UpdateRegistry).publish,
+        registryUpdated: this.createEvent<RegistryUpdatePayload>(EventNames.RegistryUpdated).publish,
+        registryUpdateError: this.createEvent<RegistryUpdatePayload>(EventNames.RegistryUpdateError).publish,
+        deleteRegistry: this.createEvent<RegistryUpdatePayload>(EventNames.DeleteRegistry).publish,
+        registryDeleted: this.createEvent<RegistryUpdatePayload>(EventNames.RegistryDeleted).publish,
+        registryDeletionError: this.createEvent<RegistryUpdatePayload>(EventNames.RegistryDeletionError).publish,
+        inviteUser: this.createEvent<{ tenant: string; user: string; role: tenantRole; }>(EventNames.InviteUser).publish,
+        userInvited: this.createEvent<{ tenant: string; user: string; role: tenantRole; }>(EventNames.UserInvited).publish,
+        inviteError: this.createEvent<{ tenant: string; user: string; role: tenantRole; }>(EventNames.UserInviteError).publish,
+        removeUser: this.createEvent<{ user: string; tenant: string; }>(EventNames.RemoveUserFromTenant).publish,
+        userRemoved: this.createEvent<{ user: string; tenant: string; }>(EventNames.UserRemovedFromTenant).publish,
+        removeUserError: this.createEvent<{ user: string; tenant: string; }>(EventNames.UserRemovalFromTenantError).publish,
+        acceptInvite: this.createEvent<{ tenant: string; }>(EventNames.AcceptInvite).publish,
+        inviteAccepted: this.createEvent<{ user: string; tenant: string; }>(EventNames.InviteAccepted).publish,
+        acceptInviteError: this.createEvent<{ tenant: string; }>(EventNames.InviteAcceptError).publish,
+        updateInvite: this.createEvent<{ tenant: string; user: string; role: tenantRole; }>(EventNames.UpdateInvite).publish,
+        inviteUpdated: this.createEvent<{ tenant: string; user: string; role: tenantRole; }>(EventNames.InviteUpdated).publish,
+        inviteUpdateError: this.createEvent<{ tenant: string; user: string;  role: tenantRole; }>(EventNames.InviteUpdateError).publish,
+        rejectInvite: this.createEvent<{ tenant: string; }>(EventNames.RejectInvite).publish,
+        inviteRejected: this.createEvent<{ user: string; tenant: string; }>(EventNames.InviteRejected).publish,
+        inviteRejectError: this.createEvent<{ tenant: string; }>(EventNames.InviteRejectError).publish,
+        createToken: this.createEvent<{ tenant: string; expiration: string; description: string }>(EventNames.CreateToken).publish,
+        tokenCreated: this.createEvent<{ tenant: string; token: string; expiration: string; description: string }>(EventNames.TokenCreated).publish,
+        tokenCreationError: this.createEvent<{ tenant: string; expiration: string; description: string }>(EventNames.TokenCreationError).publish,
+        deleteToken: this.createEvent<{ tenant: string; token: string }>(EventNames.DeleteToken).publish,
+        tokenDeleted: this.createEvent<{ tenant: string; token: string }>(EventNames.TokenDeleted).publish,
+        tokenDeletionError: this.createEvent<{ tenant: string; token: string }>(EventNames.TokenDeletionError).publish,
+      },
+      subscribe: {
+        creation: this.createEvent<Tenant>(EventNames.CreateTenant).subscribe,
+        created: this.createEvent<Tenant>(EventNames.TenantCreated).subscribe,
+        creationError: this.createEvent<Tenant>(EventNames.TenantCreationError).subscribe,
+        update: this.createEvent<Tenant>(EventNames.UpdateTenant).subscribe,
+        updated: this.createEvent<Tenant>(EventNames.TenantUpdated).subscribe,
+        updateError: this.createEvent<Tenant>(EventNames.TenantUpdateError).subscribe,
+        delete: this.createEvent<Tenant>(EventNames.DeleteTenant).subscribe,
+        deleted: this.createEvent<Tenant>(EventNames.TenantDeleted).subscribe,
+        deletionError: this.createEvent<Tenant>(EventNames.TenantDeletionError).subscribe,
+        createRegistry: this.createEvent<RegistryUpdatePayload>(EventNames.CreateRegistry).subscribe,
+        registryCreated: this.createEvent<RegistryUpdatePayload>(EventNames.RegistryCreated).subscribe,
+        registryCreationError: this.createEvent<RegistryUpdatePayload>(EventNames.RegistryCreationError).subscribe,
+        updateRegistry: this.createEvent<RegistryUpdatePayload>(EventNames.UpdateRegistry).subscribe,
+        registryUpdated: this.createEvent<RegistryUpdatePayload>(EventNames.RegistryUpdated).subscribe,
+        registryUpdateError: this.createEvent<RegistryUpdatePayload>(EventNames.RegistryUpdateError).subscribe,
+        deleteRegistry: this.createEvent<RegistryUpdatePayload>(EventNames.DeleteRegistry).subscribe,
+        registryDeleted: this.createEvent<RegistryUpdatePayload>(EventNames.RegistryDeleted).subscribe,
+        registryDeletionError: this.createEvent<RegistryUpdatePayload>(EventNames.RegistryDeletionError).subscribe,
+        inviteUser: this.createEvent<{ tenant: string; user: string; role: tenantRole; }>(EventNames.InviteUser).subscribe,
+        userInvited: this.createEvent<{ tenant: string; user: string; role: tenantRole; }>(EventNames.UserInvited).subscribe,
+        inviteError: this.createEvent<{ tenant: string; user: string; role: tenantRole; }>(EventNames.UserInviteError).subscribe,
+        removeUser: this.createEvent<{ user: string; tenant: string; }>(EventNames.RemoveUserFromTenant).subscribe,
+        userRemoved: this.createEvent<{ user: string; tenant: string; }>(EventNames.UserRemovedFromTenant).subscribe,
+        removeUserError: this.createEvent<{ user: string; tenant: string; }>(EventNames.UserRemovalFromTenantError).subscribe,
+        acceptInvite: this.createEvent<{ tenant: string; }>(EventNames.AcceptInvite).subscribe,
+        inviteAccepted: this.createEvent<{ user: string; tenant: string; }>(EventNames.InviteAccepted).subscribe,
+        acceptInviteError: this.createEvent<{ tenant: string; }>(EventNames.InviteAcceptError).subscribe,
+        updateInvite: this.createEvent<{ tenant: string; user: string; role: tenantRole; }>(EventNames.UpdateInvite).subscribe,
+        inviteUpdated: this.createEvent<{ tenant: string; user: string; role: tenantRole; }>(EventNames.InviteUpdated).subscribe,
+        inviteUpdateError: this.createEvent<{ tenant: string; user: string;  role: tenantRole; }>(EventNames.InviteUpdateError).subscribe,
+        rejectInvite: this.createEvent<{ tenant: string; }>(EventNames.RejectInvite).subscribe,
+        inviteRejected: this.createEvent<{ user: string; tenant: string; }>(EventNames.InviteRejected).subscribe,
+        inviteRejectError: this.createEvent<{ tenant: string; }>(EventNames.InviteRejectError).subscribe,
+        createToken: this.createEvent<{ tenant: string; expiration: string; description: string }>(EventNames.CreateToken).subscribe,
+        tokenCreated: this.createEvent<{ tenant: string; token: string; expiration: string; description: string }>(EventNames.TokenCreated).subscribe,
+        tokenCreationError: this.createEvent<{ tenant: string; expiration: string; description: string }>(EventNames.TokenCreationError).subscribe,
+        deleteToken: this.createEvent<{ tenant: string; token: string }>(EventNames.DeleteToken).subscribe,
+        tokenDeleted: this.createEvent<{ tenant: string; token: string }>(EventNames.TokenDeleted).subscribe,
+        tokenDeletionError: this.createEvent<{ tenant: string; token: string }>(EventNames.TokenDeletionError).subscribe,
+      },
+      unsubscribe: {
+        creation: this.createEvent<Tenant>(EventNames.CreateTenant).unsubscribe,
+        created: this.createEvent<Tenant>(EventNames.TenantCreated).unsubscribe,
+        creationError: this.createEvent<Tenant>(EventNames.TenantCreationError).unsubscribe,
+        update: this.createEvent<Tenant>(EventNames.UpdateTenant).unsubscribe,
+        updated: this.createEvent<Tenant>(EventNames.TenantUpdated).unsubscribe,
+        updateError: this.createEvent<Tenant>(EventNames.TenantUpdateError).unsubscribe,
+        delete: this.createEvent<Tenant>(EventNames.DeleteTenant).unsubscribe,
+        deleted: this.createEvent<Tenant>(EventNames.TenantDeleted).unsubscribe,
+        deletionError: this.createEvent<Tenant>(EventNames.TenantDeletionError).unsubscribe,
+        createRegistry: this.createEvent<RegistryUpdatePayload>(EventNames.CreateRegistry).unsubscribe,
+        registryCreated: this.createEvent<RegistryUpdatePayload>(EventNames.RegistryCreated).unsubscribe,
+        registryCreationError: this.createEvent<RegistryUpdatePayload>(EventNames.RegistryCreationError).unsubscribe,
+        updateRegistry: this.createEvent<RegistryUpdatePayload>(EventNames.UpdateRegistry).unsubscribe,
+        registryUpdated: this.createEvent<RegistryUpdatePayload>(EventNames.RegistryUpdated).unsubscribe,
+        registryUpdateError: this.createEvent<RegistryUpdatePayload>(EventNames.RegistryUpdateError).unsubscribe,
+        deleteRegistry: this.createEvent<RegistryUpdatePayload>(EventNames.DeleteRegistry).unsubscribe,
+        registryDeleted: this.createEvent<RegistryUpdatePayload>(EventNames.RegistryDeleted).unsubscribe,
+        registryDeletionError: this.createEvent<RegistryUpdatePayload>(EventNames.RegistryDeletionError).unsubscribe,
+        inviteUser: this.createEvent<{ tenant: string; user: string; role: tenantRole; }>(EventNames.InviteUser).unsubscribe,
+        userInvited: this.createEvent<{tenant: string; user: string; role: tenantRole; }>(EventNames.UserInvited).unsubscribe,
+        inviteError: this.createEvent<{ tenant: string; user: string; role: tenantRole; }>(EventNames.UserInviteError).unsubscribe,
+        removeUser: this.createEvent<{ user: string; tenant: string; }>(EventNames.RemoveUserFromTenant).unsubscribe,
+        userRemoved: this.createEvent<{ user: string; tenant: string; }>(EventNames.UserRemovedFromTenant).unsubscribe,
+        removeUserError: this.createEvent<{ user: string; tenant: string; }>(EventNames.UserRemovalFromTenantError).unsubscribe,
+        acceptInvite: this.createEvent<{ tenant: string; }>(EventNames.AcceptInvite).unsubscribe,
+        inviteAccepted: this.createEvent<{ user: string; tenant: string; }>(EventNames.InviteAccepted).unsubscribe,
+        acceptInviteError: this.createEvent<{ tenant: string; }>(EventNames.InviteAcceptError).unsubscribe,
+        updateInvite: this.createEvent<{ tenant: string; user: string; role: tenantRole; }>(EventNames.UpdateInvite).unsubscribe,
+        inviteUpdated: this.createEvent<{ tenant: string; user: string; role: tenantRole; }>(EventNames.InviteUpdated).unsubscribe,
+        inviteUpdateError: this.createEvent<{ tenant: string; user: string;  role: tenantRole; }>(EventNames.InviteUpdateError).unsubscribe,
+        rejectInvite: this.createEvent<{ tenant: string; }>(EventNames.RejectInvite).unsubscribe,
+        inviteRejected: this.createEvent<{ user: string; tenant: string; }>(EventNames.InviteRejected).unsubscribe,
+        inviteRejectError: this.createEvent<{ tenant: string; }>(EventNames.InviteRejectError).unsubscribe,
+        createToken: this.createEvent<{ tenant: string; expiration: string; description: string }>(EventNames.CreateToken).unsubscribe,
+        tokenCreated: this.createEvent<{ tenant: string; token: string; expiration: string; description: string }>(EventNames.TokenCreated).unsubscribe,
+        tokenCreationError: this.createEvent<{ tenant: string; expiration: string; description: string }>(EventNames.TokenCreationError).unsubscribe,
+        deleteToken: this.createEvent<{ tenant: string; token: string }>(EventNames.DeleteToken).unsubscribe,
+        tokenDeleted: this.createEvent<{ tenant: string; token: string }>(EventNames.TokenDeleted).unsubscribe,
+        tokenDeletionError: this.createEvent<{ tenant: string; token: string }>(EventNames.TokenDeletionError).unsubscribe,
+
+      },
+    };
+  }
+
+  // * User
+  get user() {
+    return {
+      publish: {
+        creation: this.createEvent<User>(EventNames.CreateUser).publish,
+        created: this.createEvent<User>(EventNames.UserCreated).publish,
+        creationError: this.createEvent<User>(EventNames.UserCreationError).publish,
+        update: this.createEvent<User>(EventNames.UpdateUser).publish,
+        updated: this.createEvent<User>(EventNames.UserUpdated).publish,
+        updateError: this.createEvent<User>(EventNames.UserUpdateError).publish,
+        load: this.createEvent<User>(EventNames.LoadUser).publish,
+        loaded: this.createEvent<User>(EventNames.UserLoaded).publish,
+        loadError: this.createEvent<User>(EventNames.UserLoadError).publish,
+        delete: this.createEvent<User>(EventNames.DeleteUser).publish,
+        deleted: this.createEvent<User>(EventNames.UserDeleted).publish,
+        deletionError: this.createEvent<User>(EventNames.UserDeletionError).publish,
+        authError: this.createEvent<User>(EventNames.AuthError).publish,
+      },
+      subscribe: {
+        creation: this.createEvent<User>(EventNames.CreateUser).subscribe,
+        created: this.createEvent<User>(EventNames.UserCreated).subscribe,
+        creationError: this.createEvent<User>(EventNames.UserCreationError).subscribe,
+        update: this.createEvent<User>(EventNames.UpdateUser).subscribe,
+        updated: this.createEvent<User>(EventNames.UserUpdated).subscribe,
+        updateError: this.createEvent<User>(EventNames.UserUpdateError).subscribe,
+        load: this.createEvent<User>(EventNames.LoadUser).subscribe,
+        loaded: this.createEvent<User>(EventNames.UserLoaded).subscribe,
+        loadError: this.createEvent<User>(EventNames.UserLoadError).subscribe,
+        delete: this.createEvent<User>(EventNames.DeleteUser).subscribe,
+        deleted: this.createEvent<User>(EventNames.UserDeleted).subscribe,
+        deletionError: this.createEvent<User>(EventNames.UserDeletionError).subscribe,
+        authError: this.createEvent<User>(EventNames.AuthError).subscribe,
+      },
+      unsubscribe: {
+        creation: this.createEvent<User>(EventNames.CreateUser).unsubscribe,
+        created: this.createEvent<User>(EventNames.UserCreated).unsubscribe,
+        creationError: this.createEvent<User>(EventNames.UserCreationError).unsubscribe,
+        update: this.createEvent<User>(EventNames.UpdateUser).unsubscribe,
+        updated: this.createEvent<User>(EventNames.UserUpdated).unsubscribe,
+        updateError: this.createEvent<User>(EventNames.UserUpdateError).unsubscribe,
+        load: this.createEvent<User>(EventNames.LoadUser).unsubscribe,
+        loaded: this.createEvent<User>(EventNames.UserLoaded).unsubscribe,
+        loadError: this.createEvent<User>(EventNames.UserLoadError).unsubscribe,
+        delete: this.createEvent<User>(EventNames.DeleteUser).unsubscribe,
+        deleted: this.createEvent<User>(EventNames.UserDeleted).unsubscribe,
+        deletionError: this.createEvent<User>(EventNames.UserDeletionError).unsubscribe,
+        authError: this.createEvent<User>(EventNames.AuthError).unsubscribe,
+      },
+    };
+  }
+
+  // * Account
+  get account() {
+    return {
+      publish: {
+        creation: this.createEvent<Account>(EventNames.CreateAccount).publish,
+        created: this.createEvent<Account>(EventNames.AccountCreated).publish,
+        creationError: this.createEvent<Account>(EventNames.AccountCreationError).publish,
+        update: this.createEvent<Account>(EventNames.UpdateAccount).publish,
+        updated: this.createEvent<Account>(EventNames.AccountUpdated).publish,
+        updateError: this.createEvent<Account>(EventNames.AccountUpdateError).publish,
+        delete: this.createEvent<Account>(EventNames.DeleteAccount).publish,
+        deleted: this.createEvent<Account>(EventNames.AccountDeleted).publish,
+        deletionError: this.createEvent<Account>(EventNames.AccountDeletionError).publish,
+        clean: this.createEvent<Account>(EventNames.CleanAccount).publish,
+        cleaned: this.createEvent<Account>(EventNames.AccountCleaned).publish,
+        cleanError: this.createEvent<Account>(EventNames.AccountCleanError).publish,
+      },
+      subscribe: {
+        creation: this.createEvent<Account>(EventNames.CreateAccount).subscribe,
+        created: this.createEvent<Account>(EventNames.AccountCreated).subscribe,
+        creationError: this.createEvent<Account>(EventNames.AccountCreationError).subscribe,
+        update: this.createEvent<Account>(EventNames.UpdateAccount).subscribe,
+        updated: this.createEvent<Account>(EventNames.AccountUpdated).subscribe,
+        updateError: this.createEvent<Account>(EventNames.AccountUpdateError).subscribe,
+        delete: this.createEvent<Account>(EventNames.DeleteAccount).subscribe,
+        deleted: this.createEvent<Account>(EventNames.AccountDeleted).subscribe,
+        deletionError: this.createEvent<Account>(EventNames.AccountDeletionError).subscribe,
+        clean: this.createEvent<Account>(EventNames.CleanAccount).subscribe,
+        cleaned: this.createEvent<Account>(EventNames.AccountCleaned).subscribe,
+        cleanError: this.createEvent<Account>(EventNames.AccountCleanError).subscribe,
+      },
+      unsubscribe: {
+        creation: this.createEvent<Account>(EventNames.CreateAccount).unsubscribe,
+        created: this.createEvent<Account>(EventNames.AccountCreated).unsubscribe,
+        creationError: this.createEvent<Account>(EventNames.AccountCreationError).unsubscribe,
+        update: this.createEvent<Account>(EventNames.UpdateAccount).unsubscribe,
+        updated: this.createEvent<Account>(EventNames.AccountUpdated).unsubscribe,
+        updateError: this.createEvent<Account>(EventNames.AccountUpdateError).unsubscribe,
+        delete: this.createEvent<Account>(EventNames.DeleteAccount).unsubscribe,
+        deleted: this.createEvent<Account>(EventNames.AccountDeleted).unsubscribe,
+        deletionError: this.createEvent<Account>(EventNames.AccountDeletionError).unsubscribe,
+        clean: this.createEvent<Account>(EventNames.CleanAccount).unsubscribe,
+        cleaned: this.createEvent<Account>(EventNames.AccountCleaned).unsubscribe,
+        cleanError: this.createEvent<Account>(EventNames.AccountCleanError).unsubscribe,
+      },
+    };
+  }
+
+  // * Environment
+  get environment() {
+    return {
+      publish: {
+        creation: this.createEvent<Environment>(EventNames.CreateEnvironment).publish,
+        created: this.createEvent<Environment>(EventNames.EnvironmentCreated).publish,
+        creationError: this.createEvent<Environment>(EventNames.EnvironmentCreationError).publish,
+        update: this.createEvent<Environment>(EventNames.UpdateEnvironment).publish,
+        updated: this.createEvent<Environment>(EventNames.EnvironmentUpdated).publish,
+        updateError: this.createEvent<Environment>(EventNames.EnvironmentUpdateError).publish,
+        delete: this.createEvent<Environment>(EventNames.DeleteEnvironment).publish,
+        deleted: this.createEvent<Environment>(EventNames.EnvironmentDeleted).publish,
+        deletionError: this.createEvent<Environment>(EventNames.EvironmentDeletionError).publish,
+        clean: this.createEvent<Environment>(EventNames.CleanEnvironment).publish,
+        cleaned: this.createEvent<Environment>(EventNames.EnvironmentCleaned).publish,
+        cleanError: this.createEvent<Environment>(EventNames.EnvironmentCleanError).publish,
+        scale: this.createEvent<Environment>(EventNames.ScaleEnvironment).publish,
+        scaled: this.createEvent<Environment>(EventNames.EnvironmentScaled).publish,
+        scaleError: this.createEvent<Environment>(EventNames.EnvironmentScaleError).publish,
+      },
+      subscribe: {
+        creation: this.createEvent<Environment>(EventNames.CreateEnvironment).subscribe,
+        created: this.createEvent<Environment>(EventNames.EnvironmentCreated).subscribe,
+        creationError: this.createEvent<Environment>(EventNames.EnvironmentCreationError).subscribe,
+        update: this.createEvent<Environment>(EventNames.UpdateEnvironment).subscribe,
+        updated: this.createEvent<Environment>(EventNames.EnvironmentUpdated).subscribe,
+        updateError: this.createEvent<Environment>(EventNames.EnvironmentUpdateError).subscribe,
+        delete: this.createEvent<Environment>(EventNames.DeleteEnvironment).subscribe,
+        deleted: this.createEvent<Environment>(EventNames.EnvironmentDeleted).subscribe,
+        deletionError: this.createEvent<Environment>(EventNames.EvironmentDeletionError).subscribe,
+        clean: this.createEvent<Environment>(EventNames.CleanEnvironment).subscribe,
+        cleaned: this.createEvent<Environment>(EventNames.EnvironmentCleaned).subscribe,
+        cleanError: this.createEvent<Environment>(EventNames.EnvironmentCleanError).subscribe,
+        scale: this.createEvent<Environment>(EventNames.ScaleEnvironment).subscribe,
+        scaled: this.createEvent<Environment>(EventNames.EnvironmentScaled).subscribe,
+        scaleError: this.createEvent<Environment>(EventNames.EnvironmentScaleError).subscribe,
+      },
+      unsubscribe: {
+        creation: this.createEvent<Environment>(EventNames.CreateEnvironment).unsubscribe,
+        created: this.createEvent<Environment>(EventNames.EnvironmentCreated).unsubscribe,
+        creationError: this.createEvent<Environment>(EventNames.EnvironmentCreationError).unsubscribe,
+        update: this.createEvent<Environment>(EventNames.UpdateEnvironment).unsubscribe,
+        updated: this.createEvent<Environment>(EventNames.EnvironmentUpdated).unsubscribe,
+        updateError: this.createEvent<Environment>(EventNames.EnvironmentUpdateError).unsubscribe,
+        delete: this.createEvent<Environment>(EventNames.DeleteEnvironment).unsubscribe,
+        deleted: this.createEvent<Environment>(EventNames.EnvironmentDeleted).unsubscribe,
+        deletionError: this.createEvent<Environment>(EventNames.EvironmentDeletionError).unsubscribe,
+        clean: this.createEvent<Environment>(EventNames.CleanEnvironment).unsubscribe,
+        cleaned: this.createEvent<Environment>(EventNames.EnvironmentCleaned).unsubscribe,
+        cleanError: this.createEvent<Environment>(EventNames.EnvironmentCleanError).unsubscribe,
+        scale: this.createEvent<Environment>(EventNames.ScaleEnvironment).unsubscribe,
+        scaled: this.createEvent<Environment>(EventNames.EnvironmentScaled).unsubscribe,
+        scaleError: this.createEvent<Environment>(EventNames.EnvironmentScaleError).unsubscribe,
+      },
+    };
+  }
+
+  // * Service
+  get service() {
+    return {
+      publish: {
+        deploy: this.createEvent<Service>(EventNames.DeployService).publish,
+        deployed: this.createEvent<Service>(EventNames.ServiceDeployed).publish,
+        deploymentError: this.createEvent<Service>(EventNames.ServiceDeploymentError).publish,
+        update: this.createEvent<Service>(EventNames.UpdateService).publish,
+        updated: this.createEvent<Service>(EventNames.ServiceUpdated).publish,
+        updateError: this.createEvent<Service>(EventNames.ServiceUpdateError).publish,
+        delete: this.createEvent<Service>(EventNames.DeleteService).publish,
+        deleted: this.createEvent<Service>(EventNames.ServiceDeleted).publish,
+        deletionError: this.createEvent<Service>(EventNames.ServiceDeletionError).publish,
+        requestLogs: this.createEvent<Service>(EventNames.RequestLogs).publish,
+        restart: this.createEvent<Service>(EventNames.RestartService).publish,
+			  restarted: this.createEvent<Service>(EventNames.ServiceRestarted).publish,
+			  restartError: this.createEvent<Service>(EventNames.ServiceRestartError).publish,
+        requestRevisionData : this.createEvent<Service>(EventNames.RequestRevisionData).publish,
+        updateServiceLinks : this.createEvent<Link>(EventNames.updateServiceLinks).publish,
+        changeRevision: this.createEvent<Service>(EventNames.ChangeRevision).publish,
+        revisionChanged: this.createEvent<Service>(EventNames.RevisionChanged).publish,
+        revisionChangeError: this.createEvent<Service>(EventNames.RevisionChangeError).publish
+      },
+      subscribe: {
+        deploy: this.createEvent<Service>(EventNames.DeployService).subscribe,
+        deployed: this.createEvent<Service>(EventNames.ServiceDeployed).subscribe,
+        deploymentError: this.createEvent<Service>(EventNames.ServiceDeploymentError).subscribe,
+        update: this.createEvent<Service>(EventNames.UpdateService).subscribe,
+        updated: this.createEvent<Service>(EventNames.ServiceUpdated).subscribe,
+        updateError: this.createEvent<Service>(EventNames.ServiceUpdateError).subscribe,
+        delete: this.createEvent<Service>(EventNames.DeleteService).subscribe,
+        deleted: this.createEvent<Service>(EventNames.ServiceDeleted).subscribe,
+        deletionError: this.createEvent<Service>(EventNames.ServiceDeletionError).subscribe,
+        requestLogs: this.createEvent<Service>(EventNames.RequestLogs).subscribe,
+        restart: this.createEvent<Service>(EventNames.RestartService).subscribe,
+			  restarted: this.createEvent<Service>(EventNames.ServiceRestarted).subscribe,
+			  restartError: this.createEvent<Service>(EventNames.ServiceRestartError).subscribe,
+        requestRevisionData : this.createEvent<Service>(EventNames.RequestRevisionData).subscribe,
+        updateServiceLinks : this.createEvent<Link>(EventNames.updateServiceLinks).subscribe,
+        changeRevision: this.createEvent<Service>(EventNames.ChangeRevision).subscribe,
+        revisionChanged: this.createEvent<Service>(EventNames.RevisionChanged).subscribe,
+        revisionChangeError: this.createEvent<Service>(EventNames.RevisionChangeError).subscribe
+      },
+      unsubscribe: {
+        deploy: this.createEvent<Service>(EventNames.DeployService).unsubscribe,
+        deployed: this.createEvent<Service>(EventNames.ServiceDeployed).unsubscribe,
+        deploymentError: this.createEvent<Service>(EventNames.ServiceDeploymentError).unsubscribe,
+        update: this.createEvent<Service>(EventNames.UpdateService).unsubscribe,
+        updated: this.createEvent<Service>(EventNames.ServiceUpdated).unsubscribe,
+        updateError: this.createEvent<Service>(EventNames.ServiceUpdateError).unsubscribe,
+        delete: this.createEvent<Service>(EventNames.DeleteService).unsubscribe,
+        deleted: this.createEvent<Service>(EventNames.ServiceDeleted).unsubscribe,
+        deletionError: this.createEvent<Service>(EventNames.ServiceDeletionError).unsubscribe,
+        requestLogs: this.createEvent<Service>(EventNames.RequestLogs).unsubscribe,
+        restart: this.createEvent<Service>(EventNames.RestartService).unsubscribe,
+			  restarted: this.createEvent<Service>(EventNames.ServiceRestarted).unsubscribe,
+			  restartError: this.createEvent<Service>(EventNames.ServiceRestartError).unsubscribe,
+        requestRevisionData : this.createEvent<Service>(EventNames.RequestRevisionData).unsubscribe,
+        updateServiceLinks : this.createEvent<Link>(EventNames.updateServiceLinks).unsubscribe,
+        changeRevision: this.createEvent<Service>(EventNames.ChangeRevision).unsubscribe,
+        revisionChanged: this.createEvent<Service>(EventNames.RevisionChanged).unsubscribe,
+        revisionChangeError: this.createEvent<Service>(EventNames.RevisionChangeError).unsubscribe
+      },
+    };
+  }
+
+  // * Marketplace
+  get marketplace() {
+    return {
+      publish: {
+        deployItem: this.createEvent<MarketplaceService>(EventNames.DeployMarketplaceItem).publish,
+        itemDeployed: this.createEvent<Service>(EventNames.MarketplaceItemDeployed).publish,
+        deploymentError: this.createEvent<Service>(EventNames.MarketplaceItemDeploymentError).publish,
+        updateItem: this.createEvent<Service>(EventNames.UpdateMarketplaceItem).publish,
+        itemUpdated: this.createEvent<Service>(EventNames.MarketplaceItemUpdated).publish,
+        updateError: this.createEvent<Service>(EventNames.MarketplaceItemUpdateError).publish,
+        deleteItem: this.createEvent<Service>(EventNames.DeleteMarketplaceItem).publish,
+        itemDeleted: this.createEvent<Service>(EventNames.MarketplaceItemDeleted).publish,
+        deletionError: this.createEvent<Service>(EventNames.MarketplaceItemDeletionError).publish,
+        loadItems: this.createEvent<string[]>(EventNames.LoadMarketplaceItems).publish,
+        itemsLoaded: this.createEvent<MarketplaceItem[]>(EventNames.MarketplaceItemsLoaded).publish,
+      },
+      subscribe: {
+        deployItem: this.createEvent<MarketplaceService>(EventNames.DeployMarketplaceItem).subscribe,
+        itemDeployed: this.createEvent<Service>(EventNames.MarketplaceItemDeployed).subscribe,
+        deploymentError: this.createEvent<Service>(EventNames.MarketplaceItemDeploymentError).subscribe,
+        updateItem: this.createEvent<Service>(EventNames.UpdateMarketplaceItem).subscribe,
+        itemUpdated: this.createEvent<Service>(EventNames.MarketplaceItemUpdated).subscribe,
+        updateError: this.createEvent<Service>(EventNames.MarketplaceItemUpdateError).subscribe,
+        deleteItem: this.createEvent<Service>(EventNames.DeleteMarketplaceItem).subscribe,
+        itemDeleted: this.createEvent<Service>(EventNames.MarketplaceItemDeleted).subscribe,
+        deletionError: this.createEvent<Service>(EventNames.MarketplaceItemDeletionError).subscribe,
+        loadItems: this.createEvent<string[]>(EventNames.LoadMarketplaceItems).subscribe,
+        itemsLoaded: this.createEvent<MarketplaceItem[]>(EventNames.MarketplaceItemsLoaded).subscribe,
+      },
+      unsubscribe: {
+        deployItem: this.createEvent<MarketplaceService>(EventNames.DeployMarketplaceItem).unsubscribe,
+        itemDeployed: this.createEvent<Service>(EventNames.MarketplaceItemDeployed).unsubscribe,
+        deploymentError: this.createEvent<Service>(EventNames.MarketplaceItemDeploymentError).unsubscribe,
+        updateItem: this.createEvent<Service>(EventNames.UpdateMarketplaceItem).unsubscribe,
+        itemUpdated: this.createEvent<Service>(EventNames.MarketplaceItemUpdated).unsubscribe,
+        updateError: this.createEvent<Service>(EventNames.MarketplaceItemUpdateError).unsubscribe,
+        deleteItem: this.createEvent<Service>(EventNames.DeleteMarketplaceItem).unsubscribe,
+        itemDeleted: this.createEvent<Service>(EventNames.MarketplaceItemDeleted).unsubscribe,
+        deletionError: this.createEvent<Service>(EventNames.MarketplaceItemDeletionError).unsubscribe,
+        loadItems: this.createEvent<string[]>(EventNames.LoadMarketplaceItems).unsubscribe,
+        itemsLoaded: this.createEvent<MarketplaceItem[]>(EventNames.MarketplaceItemsLoaded).unsubscribe,
+      },
+    };
+  }
+
+  // * Resource
+  get resource() {
+    return {
+      publish: {
+        creation: this.createEvent<Resource>(EventNames.CreateResource).publish,
+        created: this.createEvent<Resource>(EventNames.ResourceCreated).publish,
+        creationError: this.createEvent<Resource>(EventNames.ResourceCreationError).publish,
+        update: this.createEvent<Resource>(EventNames.UpdateResource).publish,
+        updated: this.createEvent<Resource>(EventNames.ResourceUpdated).publish,
+        updateError: this.createEvent<Resource>(EventNames.ResourceUpdateError).publish,
+        delete: this.createEvent<Resource>(EventNames.DeleteResource).publish,
+        deleted: this.createEvent<Resource>(EventNames.ResourceDeleted).publish,
+        deletionError: this.createEvent<Resource>(EventNames.ResourceDeletionError).publish,
+      },
+      subscribe: {
+        creation: this.createEvent<Resource>(EventNames.CreateResource).subscribe,
+        created: this.createEvent<Resource>(EventNames.ResourceCreated).subscribe,
+        creationError: this.createEvent<Resource>(EventNames.ResourceCreationError).subscribe,
+        update: this.createEvent<Resource>(EventNames.UpdateResource).subscribe,
+        updated: this.createEvent<Resource>(EventNames.ResourceUpdated).subscribe,
+        updateError: this.createEvent<Resource>(EventNames.ResourceUpdateError).subscribe,
+        delete: this.createEvent<Resource>(EventNames.DeleteResource).subscribe,
+        deleted: this.createEvent<Resource>(EventNames.ResourceDeleted).subscribe,
+        deletionError: this.createEvent<Resource>(EventNames.ResourceDeletionError).subscribe,
+      },
+      unsubscribe: {
+        creation: this.createEvent<Resource>(EventNames.CreateResource).unsubscribe,
+        created: this.createEvent<Resource>(EventNames.ResourceCreated).unsubscribe,
+        creationError: this.createEvent<Resource>(EventNames.ResourceCreationError).unsubscribe,
+        update: this.createEvent<Resource>(EventNames.UpdateResource).unsubscribe,
+        updated: this.createEvent<Resource>(EventNames.ResourceUpdated).unsubscribe,
+        updateError: this.createEvent<Resource>(EventNames.ResourceUpdateError).unsubscribe,
+        delete: this.createEvent<Resource>(EventNames.DeleteResource).unsubscribe,
+        deleted: this.createEvent<Resource>(EventNames.ResourceDeleted).unsubscribe,
+        deletionError: this.createEvent<Resource>(EventNames.ResourceDeletionError).unsubscribe,
+      },
+    };
+  }
+
+  // * Plan (payload tipo string)
+  get plan() {
+    return {
+      publish: {
+        upgrade: this.createEvent<string>(EventNames.UpdatePlan).publish,
+        upgraded: this.createEvent<string>(EventNames.PlanUpdated).publish,
+        upgradeError: this.createEvent<string>(EventNames.PlanUpdateError).publish,
+        downgrade: this.createEvent<string>(EventNames.DowngradePlan).publish,
+        downgraded: this.createEvent<string>(EventNames.PlanDowngraded).publish,
+        downgradeError: this.createEvent<string>(EventNames.PlanDowngradeError).publish,
+      },
+      subscribe: {
+        upgrade: this.createEvent<string>(EventNames.UpdatePlan).subscribe,
+        upgraded: this.createEvent<string>(EventNames.PlanUpdated).subscribe,
+        upgradeError: this.createEvent<string>(EventNames.PlanUpdateError).subscribe,
+        downgrade: this.createEvent<string>(EventNames.DowngradePlan).subscribe,
+        downgraded: this.createEvent<string>(EventNames.PlanDowngraded).subscribe,
+        downgradeError: this.createEvent<string>(EventNames.PlanDowngradeError).subscribe,
+      },
+      unsubscribe: {
+        upgrade: this.createEvent<string>(EventNames.UpdatePlan).unsubscribe,
+        upgraded: this.createEvent<string>(EventNames.PlanUpdated).unsubscribe,
+        upgradeError: this.createEvent<string>(EventNames.PlanUpdateError).unsubscribe,
+        downgrade: this.createEvent<string>(EventNames.DowngradePlan).unsubscribe,
+        downgraded: this.createEvent<string>(EventNames.PlanDowngraded).unsubscribe,
+        downgradeError: this.createEvent<string>(EventNames.PlanDowngradeError).unsubscribe,
+      },
+    };
+  }
+
+  // * Organization
+  get organization() {
+    return {
+      publish: {
+        creation: this.createEvent<Organization>(EventNames.CreateOrganization).publish,
+        created: this.createEvent<Organization>(EventNames.OrganizationCreated).publish,
+        creationError: this.createEvent<Organization>(EventNames.OrganizationCreationError).publish,
+        update: this.createEvent<Organization>(EventNames.UpdateOrganization).publish,
+        updated: this.createEvent<Organization>(EventNames.OrganizationUpdated).publish,
+        updateError: this.createEvent<Organization>(EventNames.OrganizationUpdateError).publish,
+        delete: this.createEvent<Organization>(EventNames.DeleteOrganization).publish,
+        deleted: this.createEvent<Organization>(EventNames.OrganizationDeleted).publish,
+        deletionError: this.createEvent<Organization>(EventNames.OrganizationDeletionError).publish,
+      },
+      subscribe: {
+        creation: this.createEvent<Organization>(EventNames.CreateOrganization).subscribe,
+        created: this.createEvent<Organization>(EventNames.OrganizationCreated).subscribe,
+        creationError: this.createEvent<Organization>(EventNames.OrganizationCreationError).subscribe,
+        update: this.createEvent<Organization>(EventNames.UpdateOrganization).subscribe,
+        updated: this.createEvent<Organization>(EventNames.OrganizationUpdated).subscribe,
+        updateError: this.createEvent<Organization>(EventNames.OrganizationUpdateError).subscribe,
+        delete: this.createEvent<Organization>(EventNames.DeleteOrganization).subscribe,
+        deleted: this.createEvent<Organization>(EventNames.OrganizationDeleted).subscribe,
+        deletionError: this.createEvent<Organization>(EventNames.OrganizationDeletionError).subscribe,
+      },
+      unsubscribe: {
+        creation: this.createEvent<Organization>(EventNames.CreateOrganization).unsubscribe,
+        created: this.createEvent<Organization>(EventNames.OrganizationCreated).unsubscribe,
+        creationError: this.createEvent<Organization>(EventNames.OrganizationCreationError).unsubscribe,
+        update: this.createEvent<Organization>(EventNames.UpdateOrganization).unsubscribe,
+        updated: this.createEvent<Organization>(EventNames.OrganizationUpdated).unsubscribe,
+        updateError: this.createEvent<Organization>(EventNames.OrganizationUpdateError).unsubscribe,
+        delete: this.createEvent<Organization>(EventNames.DeleteOrganization).unsubscribe,
+        deleted: this.createEvent<Organization>(EventNames.OrganizationDeleted).unsubscribe,
+        deletionError: this.createEvent<Organization>(EventNames.OrganizationDeletionError).unsubscribe,
+      },
+    };
+  }
+  // * Notification
+  get notification(){
+    return{
+      publish: {
+        creation: this.createEvent<Notification>(EventNames.CreateNotification).publish,
+        deletion: this.createEvent<Notification>(EventNames.DeleteNotification).publish,
+        read: this.createEvent<Notification>(EventNames.NotificationRead).publish
+      },
+      subscribe: {
+        creation: this.createEvent<Notification>(EventNames.CreateNotification).subscribe,
+        deletion: this.createEvent<Notification>(EventNames.DeleteNotification).subscribe,
+        read: this.createEvent<Notification>(EventNames.NotificationRead).subscribe
+      },
+      unsubscribe: {
+        creation: this.createEvent<Notification>(EventNames.CreateNotification).unsubscribe,
+        deletion: this.createEvent<Notification>(EventNames.DeleteNotification).unsubscribe,
+        read: this.createEvent<Notification>(EventNames.NotificationRead).unsubscribe
+      }
+    }
+  }
+  get planProviders() {
+    return {
+      publish: {
+        loadPlans: this.createEvent<void>(EventNames.LoadPlanProviders).publish,
+        plansLoaded: this.createEvent<PlanProvider[]>(EventNames.PlanProvidersLoaded).publish,
+        loadError: this.createEvent<void>(EventNames.PlanProvidersLoadError).publish
+      },
+      subscribe: {
+        loadPlans: this.createEvent<void>(EventNames.LoadPlanProviders).subscribe,
+        plansLoaded: this.createEvent<PlanProvider[]>(EventNames.PlanProvidersLoaded).subscribe,
+        loadError: this.createEvent<void>(EventNames.PlanProvidersLoadError).subscribe
+      },
+      unsubscribe: {
+        loadPlans: this.createEvent<void>(EventNames.LoadPlanProviders).unsubscribe,
+        plansLoaded: this.createEvent<PlanProvider[]>(EventNames.PlanProvidersLoaded).unsubscribe,
+        loadError: this.createEvent<void>(EventNames.PlanProvidersLoadError).unsubscribe
+      },
+    };
+  }
+}
+
+export default EventHelper;