@ludeo/cloud-common 1.0.0

package/dist/types/index.d.ts

@@ -0,0 +1,81 @@
+import { GameCast } from "@ludeo/aws-gamecast-sdk";
+export declare class AWSRequestData {
+  signalRequest: string;
+}
+export type CloudProviderRequest = AWSRequestData;
+export declare class CloudProviderRequestData {
+  authToken: string;
+  appToken: string;
+  cloudProviderRequest: CloudProviderRequest;
+}
+export declare enum CloudProvider {
+  AWS = "aws",
+}
+export declare class AWSResourceCreationConfig {
+  streamGroupId: string;
+  identifier: GameCast.Identifier;
+  additionalEnvironmentVariables?: GameCast.EnvironmentVariables;
+  protocol?: GameCast.Protocol;
+  connectionTimeoutSeconds?: GameCast.ConnectionTimeoutSeconds;
+  sessionLengthSeconds?: GameCast.SessionLengthSeconds;
+  applicationIdentifier?: GameCast.Identifier;
+  region?: string;
+}
+export type CloudResourceCreationConfig = AWSResourceCreationConfig;
+export declare enum CloudResourceStatus {
+  Allocated = "allocated",
+  Available = "available",
+  Creating = "creating",
+  Allocating = "allocating",
+  Error = "error",
+  Terminated = "terminated",
+  Terminating = "terminating",
+}
+export declare class AllocateCloudResourceRequestData {
+  providerSettings: CloudResourceCreationConfig;
+  requestData: CloudProviderRequestData;
+}
+export declare class AwsAllocationData {
+  streamGroupId: string;
+  streamSessionId: string;
+  signalResponse: string;
+}
+export type CloudProviderAllocationData = AwsAllocationData;
+export declare class AWSResourceProviderSettings {
+  streamSessionId: string;
+  streamGroupId: string;
+}
+export declare class AWSCreationResponse {
+  signalResponse?: GameCast.SignalResponse;
+  streamSessionId: string;
+}
+export type CreationResponse = AWSCreationResponse;
+export declare enum CloudPoolStatus {
+  Active = "active",
+  Scaling = "scaling",
+  Terminated = "terminated",
+}
+export declare class CloudPoolConfiguration {
+  providerSettings?: CloudResourceCreationConfig;
+  cloudProvider: CloudProvider;
+  poolId: string;
+  poolScaleConfiguration: PoolScaleConfiguration;
+}
+export type CloudResourcesMap = Record<
+  string,
+  {
+    status: CloudResourceStatus;
+  }
+>;
+export declare class PoolScaleConfiguration {
+  size: number;
+}
+export declare class PoolItemAllocatedPayload {
+  allocationData?: CloudProviderAllocationData;
+}
+export type CloudResourcesStatusMap = Record<CloudResourceStatus, number>;
+export declare class AllocationRequestData {
+  authToken: string;
+  appToken: string;
+  cloudProviderRequest: CloudProviderRequest;
+}

package/dist/types/index.js

@@ -0,0 +1,112 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AllocationRequestData = exports.PoolItemAllocatedPayload = exports.PoolScaleConfiguration = exports.CloudPoolConfiguration = exports.CloudPoolStatus = exports.AWSCreationResponse = exports.AWSResourceProviderSettings = exports.AwsAllocationData = exports.AllocateCloudResourceRequestData = exports.CloudResourceStatus = exports.AWSResourceCreationConfig = exports.CloudProvider = exports.CloudProviderRequestData = exports.AWSRequestData = void 0;
+const class_validator_1 = require("class-validator");
+const validate_nested_type_decorator_1 = require("../decorators/validate-nested-type.decorator");
+const aws_gamecast_sdk_1 = require("@ludeo/aws-gamecast-sdk");
+class AWSRequestData {
+}
+exports.AWSRequestData = AWSRequestData;
+__decorate([
+    (0, class_validator_1.IsString)(),
+    (0, class_validator_1.IsNotEmpty)(),
+    __metadata("design:type", String)
+], AWSRequestData.prototype, "signalRequest", void 0);
+class CloudProviderRequestData {
+}
+exports.CloudProviderRequestData = CloudProviderRequestData;
+__decorate([
+    (0, class_validator_1.IsUUID)(),
+    __metadata("design:type", String)
+], CloudProviderRequestData.prototype, "authToken", void 0);
+__decorate([
+    (0, class_validator_1.IsUUID)(),
+    __metadata("design:type", String)
+], CloudProviderRequestData.prototype, "appToken", void 0);
+__decorate([
+    (0, class_validator_1.IsDefined)(),
+    (0, validate_nested_type_decorator_1.ValidateNestedType)(() => AWSRequestData),
+    __metadata("design:type", Object)
+], CloudProviderRequestData.prototype, "cloudProviderRequest", void 0);
+var CloudProvider;
+(function (CloudProvider) {
+    CloudProvider["AWS"] = "aws";
+})(CloudProvider || (exports.CloudProvider = CloudProvider = {}));
+class AWSResourceCreationConfig {
+}
+exports.AWSResourceCreationConfig = AWSResourceCreationConfig;
+var CloudResourceStatus;
+(function (CloudResourceStatus) {
+    CloudResourceStatus["Allocated"] = "allocated";
+    CloudResourceStatus["Available"] = "available";
+    CloudResourceStatus["Creating"] = "creating";
+    CloudResourceStatus["Allocating"] = "allocating";
+    CloudResourceStatus["Error"] = "error";
+    CloudResourceStatus["Terminated"] = "terminated";
+    CloudResourceStatus["Terminating"] = "terminating";
+})(CloudResourceStatus || (exports.CloudResourceStatus = CloudResourceStatus = {}));
+class AllocateCloudResourceRequestData {
+}
+exports.AllocateCloudResourceRequestData = AllocateCloudResourceRequestData;
+class AwsAllocationData {
+}
+exports.AwsAllocationData = AwsAllocationData;
+class AWSResourceProviderSettings {
+}
+exports.AWSResourceProviderSettings = AWSResourceProviderSettings;
+class AWSCreationResponse {
+}
+exports.AWSCreationResponse = AWSCreationResponse;
+__decorate([
+    (0, class_validator_1.IsOptional)(),
+    __metadata("design:type", String)
+], AWSCreationResponse.prototype, "signalResponse", void 0);
+__decorate([
+    (0, class_validator_1.IsString)(),
+    (0, class_validator_1.IsNotEmpty)(),
+    __metadata("design:type", String)
+], AWSCreationResponse.prototype, "streamSessionId", void 0);
+var CloudPoolStatus;
+(function (CloudPoolStatus) {
+    CloudPoolStatus["Active"] = "active";
+    CloudPoolStatus["Scaling"] = "scaling";
+    CloudPoolStatus["Terminated"] = "terminated";
+})(CloudPoolStatus || (exports.CloudPoolStatus = CloudPoolStatus = {}));
+class CloudPoolConfiguration {
+}
+exports.CloudPoolConfiguration = CloudPoolConfiguration;
+__decorate([
+    (0, class_validator_1.IsEnum)(CloudProvider),
+    __metadata("design:type", String)
+], CloudPoolConfiguration.prototype, "cloudProvider", void 0);
+__decorate([
+    (0, class_validator_1.IsUUID)(),
+    __metadata("design:type", String)
+], CloudPoolConfiguration.prototype, "poolId", void 0);
+class PoolScaleConfiguration {
+}
+exports.PoolScaleConfiguration = PoolScaleConfiguration;
+__decorate([
+    (0, class_validator_1.IsNumber)(),
+    __metadata("design:type", Number)
+], PoolScaleConfiguration.prototype, "size", void 0);
+class PoolItemAllocatedPayload {
+}
+exports.PoolItemAllocatedPayload = PoolItemAllocatedPayload;
+__decorate([
+    (0, validate_nested_type_decorator_1.ValidateNestedType)(() => AwsAllocationData),
+    __metadata("design:type", Object)
+], PoolItemAllocatedPayload.prototype, "allocationData", void 0);
+class AllocationRequestData {
+}
+exports.AllocationRequestData = AllocationRequestData;
+//# sourceMappingURL=index.js.map

package/dist/types/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/types/index.ts"],"names":[],"mappings":";;;;;;;;;;;;AAAA,qDAQyB;AACzB,iGAAkF;AAClF,8DAAmD;AAEnD,MAAa,cAAc;CAI1B;AAJD,wCAIC;AADC;IAFC,IAAA,0BAAQ,GAAE;IACV,IAAA,4BAAU,GAAE;;qDACS;AAKxB,MAAa,wBAAwB;CAUpC;AAVD,4DAUC;AARC;IADC,IAAA,wBAAM,GAAE;;2DACS;AAGlB;IADC,IAAA,wBAAM,GAAE;;0DACQ;AAIjB;IAFC,IAAA,2BAAS,GAAE;IACX,IAAA,mDAAkB,EAAC,GAAG,EAAE,CAAC,cAAc,CAAC;;sEACE;AAG7C,IAAY,aAEX;AAFD,WAAY,aAAa;IACvB,4BAAW,CAAA;AACb,CAAC,EAFW,aAAa,6BAAb,aAAa,QAExB;AAED,MAAa,yBAAyB;CASrC;AATD,8DASC;AAID,IAAY,mBAQX;AARD,WAAY,mBAAmB;IAC7B,8CAAuB,CAAA;IACvB,8CAAuB,CAAA;IACvB,4CAAqB,CAAA;IACrB,gDAAyB,CAAA;IACzB,sCAAe,CAAA;IACf,gDAAyB,CAAA;IACzB,kDAA2B,CAAA;AAC7B,CAAC,EARW,mBAAmB,mCAAnB,mBAAmB,QAQ9B;AAED,MAAa,gCAAgC;CAG5C;AAHD,4EAGC;AAED,MAAa,iBAAiB;CAI7B;AAJD,8CAIC;AAID,MAAa,2BAA2B;CAGvC;AAHD,kEAGC;AAED,MAAa,mBAAmB;CAO/B;AAPD,kDAOC;AALC;IADC,IAAA,4BAAU,GAAE;;2DAC4B;AAIzC;IAFC,IAAA,0BAAQ,GAAE;IACV,IAAA,4BAAU,GAAE;;4DACW;AAK1B,IAAY,eAIX;AAJD,WAAY,eAAe;IACzB,oCAAiB,CAAA;IACjB,sCAAmB,CAAA;IACnB,4CAAyB,CAAA;AAC3B,CAAC,EAJW,eAAe,+BAAf,eAAe,QAI1B;AAED,MAAa,sBAAsB;CAOlC;AAPD,wDAOC;AAJC;IADC,IAAA,wBAAM,EAAC,aAAa,CAAC;;6DACO;AAE7B;IADC,IAAA,wBAAM,GAAE;;sDACM;AAMjB,MAAa,sBAAsB;CAGlC;AAHD,wDAGC;AADC;IADC,IAAA,0BAAQ,GAAE;;oDACE;AAGf,MAAa,wBAAwB;CAGpC;AAHD,4DAGC;AADC;IADC,IAAA,mDAAkB,EAAC,GAAG,EAAE,CAAC,iBAAiB,CAAC;;gEACC;AAK/C,MAAa,qBAAqB;CAIjC;AAJD,sDAIC"}

package/package.json

@@ -0,0 +1,19 @@
+{
+  "name": "@ludeo/cloud-common",
+  "version": "1.0.0",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "author": "Yahil Didi",
+  "scripts": {
+    "build": "tsc"
+  },
+  "dependencies": {
+    "@ludeo/aws-gamecast-sdk": "^2.1626.4",
+    "@nestjs/common": "^10.3.10",
+    "class-transformer": "^0.5.1",
+    "class-validator": "^0.14.1"
+  },
+  "devDependencies": {
+    "typescript": "^5.5.3"
+  }
+}

package/src/contexts/cloud-resource-context.ts

@@ -0,0 +1,15 @@
+import { IsString, IsUUID } from "class-validator";
+
+export class CloudResourceContext {
+  @IsUUID()
+  resourceId: string;
+
+  @IsString()
+  streamGroupId: string;
+
+  @IsString()
+  streamSessionId: string;
+
+  @IsUUID()
+  poolId: string;
+}

package/src/contexts/cloud-session-context.ts

@@ -0,0 +1,38 @@
+import { IsEnum, IsOptional, IsUUID } from "class-validator";
+import { CloudProvider } from "../types";
+
+export class CloudSessionContext {
+  @IsOptional()
+  @IsUUID()
+  allocationRequestId?: string;
+
+  @IsOptional()
+  @IsUUID()
+  clientRequestId?: string;
+
+  @IsUUID()
+  cloudSessionId: string;
+
+  @IsOptional()
+  @IsUUID()
+  userId?: string;
+
+  @IsOptional()
+  @IsUUID()
+  gameId?: string;
+
+  @IsOptional()
+  @IsUUID()
+  ludeoId?: string;
+
+  @IsOptional()
+  @IsUUID()
+  poolId?: string;
+
+  @IsEnum(CloudProvider)
+  cloudProvider: CloudProvider;
+
+  @IsOptional()
+  @IsUUID()
+  resourceId?: string;
+}

package/src/contexts/create-cloud-resource-request-context.ts

@@ -0,0 +1,11 @@
+import { IsEnum, IsUUID } from "class-validator";
+import { CloudProvider } from "../types";
+
+export class CreateCloudResourceRequestContext {
+  @IsUUID()
+  poolId: string;
+  @IsUUID()
+  resourceId: string;
+  @IsEnum(CloudProvider)
+  cloudProvider: string;
+}

package/src/contexts/index.ts

@@ -0,0 +1,4 @@
+export * from "./cloud-resource-context";
+export * from "./cloud-session-context";
+export * from "./create-cloud-resource-request-context";
+export * from "./pool-context";

package/src/contexts/pool-context.ts

@@ -0,0 +1,10 @@
+import { IsEnum, IsUUID } from "class-validator";
+import { CloudProvider } from "../types";
+
+export class PoolContext {
+  @IsEnum(CloudProvider)
+  cloudProvider: CloudProvider;
+
+  @IsUUID()
+  poolId: string;
+}

package/src/decorators/validate-nested-type.decorator.ts

@@ -0,0 +1,7 @@
+import { applyDecorators } from "@nestjs/common";
+import { ValidateNested } from "class-validator";
+import { Type } from "class-transformer";
+
+export function ValidateNestedType(typeFunction: () => any) {
+  return applyDecorators(ValidateNested(), Type(typeFunction));
+}

package/src/events/allocate-cloud-resource-request.event.ts

@@ -0,0 +1,34 @@
+import { CloudSessionContext } from "../contexts/cloud-session-context";
+import { ValidateNestedType } from "../decorators/validate-nested-type.decorator";
+import { LudeoEvent } from "../infra/ludeo-event";
+import {
+  AWSResourceCreationConfig,
+  CloudProviderRequestData,
+  CloudResourceCreationConfig,
+} from "../types";
+
+export class AllocateCloudResourceRequestPayload {
+  @ValidateNestedType(() => AWSResourceCreationConfig)
+  providerSettings: CloudResourceCreationConfig;
+  @ValidateNestedType(() => CloudProviderRequestData)
+  requestData: CloudProviderRequestData;
+}
+
+export class AllocateCloudResourceRequestEvent extends LudeoEvent {
+  static readonly EVENT_NAME = "cloud-pools.allocate-cloud-resource-request";
+
+  constructor(
+    payload: AllocateCloudResourceRequestPayload,
+    context: CloudSessionContext
+  ) {
+    super(AllocateCloudResourceRequestEvent.EVENT_NAME);
+    this.payload = payload;
+    this.context = context;
+  }
+
+  @ValidateNestedType(() => CloudSessionContext)
+  context: CloudSessionContext;
+
+  @ValidateNestedType(() => AllocateCloudResourceRequestPayload)
+  payload: AllocateCloudResourceRequestPayload;
+}

package/src/events/allocate-cloud-session-failed.event.ts

@@ -0,0 +1,28 @@
+import { IsString } from "class-validator";
+import { CloudSessionContext } from "../contexts/cloud-session-context";
+import { ValidateNestedType } from "../decorators/validate-nested-type.decorator";
+import { LudeoEvent } from "../infra/ludeo-event";
+
+export class AllocateCloudSessionFailedPayload {
+  @IsString()
+  error: string;
+}
+export class AllocateCloudSessionFailed extends LudeoEvent {
+  static readonly EVENT_NAME =
+    "cloud-session-allocator.allocate-cloud-session-failed";
+
+  constructor(
+    payload: AllocateCloudSessionFailedPayload,
+    context: CloudSessionContext
+  ) {
+    super(AllocateCloudSessionFailed.EVENT_NAME);
+    this.payload = payload;
+    this.context = context;
+  }
+
+  @ValidateNestedType(() => AllocateCloudSessionFailedPayload)
+  payload: AllocateCloudSessionFailedPayload;
+
+  @ValidateNestedType(() => CloudSessionContext)
+  context: CloudSessionContext;
+}

package/src/events/allocate-cloud-session-request.event.ts

@@ -0,0 +1,28 @@
+import { CloudSessionContext } from "../contexts/cloud-session-context";
+import { ValidateNestedType } from "../decorators/validate-nested-type.decorator";
+import { LudeoEvent } from "../infra/ludeo-event";
+import { AllocationRequestData } from "../types";
+
+export class AllocateCloudSessionRequestPayload {
+  @ValidateNestedType(() => AllocationRequestData)
+  requestData: AllocationRequestData;
+}
+
+export class AllocateCloudSessionRequest extends LudeoEvent {
+  static readonly EVENT_NAME = "cloud-sessions.allocate-cloud-session-request";
+
+  constructor(
+    payload: AllocateCloudSessionRequestPayload,
+    context: CloudSessionContext
+  ) {
+    super(AllocateCloudSessionRequest.EVENT_NAME);
+    this.payload = payload;
+    this.context = context;
+  }
+
+  @ValidateNestedType(() => AllocateCloudSessionRequestPayload)
+  payload: AllocateCloudSessionRequestPayload;
+
+  @ValidateNestedType(() => CloudSessionContext)
+  context: CloudSessionContext;
+}

package/src/events/allocate-pool-item-failed.event.ts

@@ -0,0 +1,28 @@
+import { IsString } from "class-validator";
+import { CloudSessionContext } from "../contexts/cloud-session-context";
+import { ValidateNestedType } from "../decorators/validate-nested-type.decorator";
+import { LudeoEvent } from "../infra/ludeo-event";
+
+export class AllocatePoolItemFailedPayload {
+  @IsString()
+  error: string;
+}
+
+export class AllocatePoolItemFailed extends LudeoEvent {
+  static readonly EVENT_NAME = "cloud-pools.allocate-pool-item-failed";
+
+  constructor(
+    payload: AllocatePoolItemFailedPayload,
+    context: CloudSessionContext
+  ) {
+    super(AllocatePoolItemFailed.EVENT_NAME);
+    this.payload = payload;
+    this.context = context;
+  }
+
+  @ValidateNestedType(() => AllocatePoolItemFailedPayload)
+  payload: AllocatePoolItemFailedPayload;
+
+  @ValidateNestedType(() => CloudSessionContext)
+  context: CloudSessionContext;
+}

package/src/events/allocate-pool-item-request.event.ts

@@ -0,0 +1,29 @@
+import { LudeoEvent } from "../infra/ludeo-event";
+import { ValidateNestedType } from "../decorators/validate-nested-type.decorator";
+import { CloudSessionContext } from "../contexts/cloud-session-context";
+import { CloudProviderRequestData } from "../types";
+
+export class AllocatePoolItemRequestPayload {
+  @ValidateNestedType(() => CloudProviderRequestData)
+  requestData: CloudProviderRequestData;
+}
+
+export class AllocatePoolItemRequestEvent extends LudeoEvent {
+  static readonly EVENT_NAME =
+    "cloud-session-allocator.allocate-pool-item-request";
+
+  constructor(
+    payload: AllocatePoolItemRequestPayload,
+    context: CloudSessionContext
+  ) {
+    super(AllocatePoolItemRequestEvent.EVENT_NAME);
+    this.payload = payload;
+    this.context = context;
+  }
+
+  @ValidateNestedType(() => CloudSessionContext)
+  context: CloudSessionContext;
+
+  @ValidateNestedType(() => AllocatePoolItemRequestPayload)
+  payload: AllocatePoolItemRequestPayload;
+}

package/src/events/cloud-resource-allocated.event.ts

@@ -0,0 +1,28 @@
+import { CloudSessionContext } from "../contexts/cloud-session-context";
+import { ValidateNestedType } from "../decorators/validate-nested-type.decorator";
+import { LudeoEvent } from "../infra/ludeo-event";
+import { AwsAllocationData, CloudProviderAllocationData } from "../types";
+
+export class CloudResourceAllocatedPayload {
+  @ValidateNestedType(() => AwsAllocationData)
+  allocationData: CloudProviderAllocationData;
+}
+
+export class CloudResourceAllocatedEvent extends LudeoEvent {
+  static readonly EVENT_NAME = "cloud-resources.cloud-resource-allocated";
+
+  constructor(
+    payload: CloudResourceAllocatedPayload,
+    context: CloudSessionContext
+  ) {
+    super(CloudResourceAllocatedEvent.EVENT_NAME);
+    this.payload = payload;
+    this.context = context;
+  }
+
+  @ValidateNestedType(() => CloudSessionContext)
+  context: CloudSessionContext;
+
+  @ValidateNestedType(() => CloudResourceAllocatedPayload)
+  payload: CloudResourceAllocatedPayload;
+}

package/src/events/cloud-resource-created.event.ts

@@ -0,0 +1,38 @@
+import { LudeoEvent } from "../infra/ludeo-event";
+import { AWSCreationResponse, CloudProvider, CreationResponse } from "../types";
+import { CloudSessionContext } from "../contexts/cloud-session-context";
+import { IsEnum, IsOptional, IsString, IsUUID } from "class-validator";
+import { ValidateNestedType } from "../decorators/validate-nested-type.decorator";
+
+export class CloudResourceCreatedPayload {
+  @IsUUID()
+  resourceId: string;
+  @IsUUID()
+  poolId: string;
+  @IsEnum(CloudProvider)
+  cloudProvider: CloudProvider;
+  @IsString()
+  @IsOptional()
+  clientRequestId?: string;
+  @IsOptional()
+  @IsString()
+  cloudSessionId?: string;
+  @ValidateNestedType(() => AWSCreationResponse)
+  creationResponse: CreationResponse;
+}
+
+export class CloudResourceCreated extends LudeoEvent {
+  static readonly EVENT_NAME = "cloud-resources.cloud-resource-created";
+
+  constructor({ payload = null, context = null }) {
+    super(CloudResourceCreated.EVENT_NAME);
+    this.payload = payload;
+    this.context = context;
+  }
+
+  @ValidateNestedType(() => CloudResourceCreatedPayload)
+  payload: CloudResourceCreatedPayload;
+
+  @ValidateNestedType(() => CloudSessionContext)
+  context: CloudSessionContext;
+}

package/src/events/cloud-resource-creation-failed.event.ts

@@ -0,0 +1,56 @@
+import { LudeoEvent } from "../infra/ludeo-event";
+import { CloudSessionContext } from "../contexts/cloud-session-context";
+import { ValidateNestedType } from "../decorators/validate-nested-type.decorator";
+import {
+  IsEnum,
+  IsNotEmpty,
+  IsOptional,
+  IsString,
+  IsUUID,
+} from "class-validator";
+import { AWSCreationResponse, CloudProvider, CreationResponse } from "../types";
+
+export class CloudResourceCreationFailedPayload {
+  @IsUUID()
+  resourceId: string;
+
+  @IsUUID()
+  poolId: string;
+
+  @IsEnum(CloudProvider)
+  cloudProvider: CloudProvider;
+
+  @IsOptional()
+  @IsUUID()
+  clientRequestId?: string;
+
+  @IsOptional()
+  @IsUUID()
+  cloudSessionId?: string;
+
+  @ValidateNestedType(() => AWSCreationResponse)
+  creationResponse: CreationResponse;
+
+  @IsString()
+  @IsNotEmpty()
+  error: string;
+}
+
+export class CloudResourceCreationFailedEvent extends LudeoEvent {
+  static readonly EVENT_NAME = "cloud-resources.cloud-resource-creation-failed";
+
+  constructor(
+    payload: CloudResourceCreationFailedPayload,
+    context: CloudSessionContext
+  ) {
+    super(CloudResourceCreationFailedEvent.EVENT_NAME);
+    this.payload = payload;
+    this.context = context;
+  }
+
+  @ValidateNestedType(() => CloudSessionContext)
+  context: CloudSessionContext;
+
+  @ValidateNestedType(() => CloudResourceCreationFailedPayload)
+  payload: CloudResourceCreationFailedPayload;
+}

package/src/events/cloud-resource-status.event.ts

@@ -0,0 +1,39 @@
+import { IsOptional, IsString, IsUUID } from "class-validator";
+import { LudeoEvent } from "../infra/ludeo-event";
+import { CloudResourceContext } from "../contexts/cloud-resource-context";
+import { AWSResourceProviderSettings, CloudResourceStatus } from "../types";
+import { ValidateNestedType } from "../decorators/validate-nested-type.decorator";
+
+export class CloudResourceStatusEventPayload {
+  @IsUUID()
+  resourceId: string;
+
+  @ValidateNestedType(() => AWSResourceProviderSettings)
+  providerSettings: AWSResourceProviderSettings;
+
+  @IsString()
+  status: CloudResourceStatus;
+
+  @IsOptional()
+  @IsString()
+  error?: string;
+}
+
+export class CloudResourceStatusEvent extends LudeoEvent {
+  static readonly EVENT_NAME = "cloud-resource-monitor.cloud-resource-status";
+
+  constructor(
+    payload: CloudResourceStatusEventPayload,
+    context: CloudResourceContext
+  ) {
+    super(CloudResourceStatusEvent.EVENT_NAME);
+    this.payload = payload;
+    this.context = context;
+  }
+
+  @ValidateNestedType(() => CloudResourceContext)
+  context: CloudResourceContext;
+
+  @ValidateNestedType(() => CloudResourceStatusEventPayload)
+  payload: CloudResourceStatusEventPayload;
+}

package/src/events/cloud-session-allocated.event.ts

@@ -0,0 +1,29 @@
+import { CloudSessionContext } from "../contexts/cloud-session-context";
+import { ValidateNestedType } from "../decorators/validate-nested-type.decorator";
+import { LudeoEvent } from "../infra/ludeo-event";
+import { AwsAllocationData, CloudProviderAllocationData } from "../types";
+
+export class CloudSessionAllocatedPayload {
+  @ValidateNestedType(() => AwsAllocationData)
+  allocationData?: CloudProviderAllocationData;
+}
+
+export class CloudSessionAllocated extends LudeoEvent {
+  static readonly EVENT_NAME =
+    "cloud-session-allocator.cloud-session-allocated";
+
+  constructor(
+    payload: CloudSessionAllocatedPayload,
+    context: CloudSessionContext
+  ) {
+    super(CloudSessionAllocated.EVENT_NAME);
+    this.payload = payload;
+    this.context = context;
+  }
+
+  @ValidateNestedType(() => CloudSessionAllocatedPayload)
+  payload: CloudSessionAllocatedPayload;
+
+  @ValidateNestedType(() => CloudSessionContext)
+  context: CloudSessionContext;
+}

package/src/events/cloud-session-ended.event.ts

@@ -0,0 +1,17 @@
+import { CloudSessionContext } from "../contexts/cloud-session-context";
+import { ValidateNestedType } from "../decorators/validate-nested-type.decorator";
+import { LudeoEvent } from "../infra/ludeo-event";
+
+export class CloudSessionTerminated extends LudeoEvent {
+  static readonly EVENT_NAME = "cloud-sessions.cloud-session-terminated";
+
+  constructor(context: CloudSessionContext) {
+    super(CloudSessionTerminated.EVENT_NAME);
+    this.context = context;
+  }
+
+  @ValidateNestedType(() => CloudSessionContext)
+  context: CloudSessionContext;
+
+  payload: never;
+}