import { loadUser } from './api/user-api-service';
import { Account, Environment, Link, MarketplaceItem, MarketplaceService, Organization, PlanProvider, Registry, Tenant, tenantRole, User, Service, Notification, Resource } from "@kumori/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; leave: boolean }>(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; leave: boolean }>(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; leave: boolean }>(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,
        restartInstance: this.createEvent<{ service: Service; roleId: string; instanceId: string }>(EventNames.RestartInstance).publish,
        instanceRestarted: this.createEvent<{ service: Service; roleId: string; instanceId: string }>(EventNames.InstanceRestarted).publish,
        instanceRestartError: this.createEvent<{ service: Service; roleId: string; instanceId: string }>(EventNames.InstanceRestartError).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,
        restartInstance: this.createEvent<{ service: Service; roleId: string; instanceId: string }>(EventNames.RestartInstance).subscribe,
        instanceRestarted: this.createEvent<{ service: Service; roleId: string; instanceId: string }>(EventNames.InstanceRestarted).subscribe,
        instanceRestartError: this.createEvent<{ service: Service; roleId: string; instanceId: string }>(EventNames.InstanceRestartError).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,
        restartInstance: this.createEvent<{ service: Service; roleId: string; instanceId: string }>(EventNames.RestartInstance).unsubscribe,
        instanceRestarted: this.createEvent<{ service: Service; roleId: string; instanceId: string }>(EventNames.InstanceRestarted).unsubscribe,
        instanceRestartError: this.createEvent<{ service: Service; roleId: string; instanceId: string }>(EventNames.InstanceRestartError).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,
        loadSchema: this.createEvent<string>(EventNames.LoadMarketplaceSchema).publish,
        schemaLoaded: this.createEvent<MarketplaceItem>(EventNames.MarketplaceSchemaLoaded).publish,
        schemaLoadError: this.createEvent<string>(EventNames.MarketplaceSchemaLoadError).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,
        loadSchema: this.createEvent<string>(EventNames.LoadMarketplaceSchema).subscribe,
        schemaLoaded: this.createEvent<MarketplaceItem>(EventNames.MarketplaceSchemaLoaded).subscribe,
        schemaLoadError: this.createEvent<string>(EventNames.MarketplaceSchemaLoadError).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,
        loadSchema: this.createEvent<string>(EventNames.LoadMarketplaceSchema).unsubscribe,
        schemaLoaded: this.createEvent<MarketplaceItem>(EventNames.MarketplaceSchemaLoaded).unsubscribe,
        schemaLoadError: this.createEvent<string>(EventNames.MarketplaceSchemaLoadError).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;