From d4d259a6cc416a8bbe24767fb376fb2be7ae8b47 Mon Sep 17 00:00:00 2001 From: ci core model Date: Thu, 20 Mar 2025 11:08:55 +0000 Subject: [PATCH] Latest generation --- actorInput.client.ts | 25 ++- actorInput.ts | 400 ++++++++++++++++++++++++++++++++++++++++++- package.json | 2 +- 3 files changed, 419 insertions(+), 8 deletions(-) diff --git a/actorInput.client.ts b/actorInput.client.ts index 7860bb98..e1351d22 100644 --- a/actorInput.client.ts +++ b/actorInput.client.ts @@ -16,6 +16,8 @@ import type { ActorSnapshotCompletedResponse } from "./actorInput"; import type { ActorSnapshotCompletedRequest } from "./actorInput"; import type { ActorDeletedResponse } from "./actorInput"; import type { ActorDeletedRequest } from "./actorInput"; +import type { ActorCreatedv2Response } from "./actorInput"; +import type { ActorCreatedv2Request } from "./actorInput"; import { stackIntercept } from "@protobuf-ts/runtime-rpc"; import type { ActorCreatedResponse } from "./actorInput"; import type { ActorCreatedRequest } from "./actorInput"; @@ -32,6 +34,10 @@ export interface IActorInputAPIClient { * @generated from protobuf rpc: Created(api.ActorCreatedRequest) returns (api.ActorCreatedResponse); */ created(input: ActorCreatedRequest, options?: RpcOptions): UnaryCall; + /** + * @generated from protobuf rpc: Createdv2(api.ActorCreatedv2Request) returns (api.ActorCreatedv2Response); + */ + createdv2(input: ActorCreatedv2Request, options?: RpcOptions): UnaryCall; /** * @generated from protobuf rpc: Deleted(api.ActorDeletedRequest) returns (api.ActorDeletedResponse); */ @@ -76,46 +82,53 @@ export class ActorInputAPIClient implements IActorInputAPIClient, ServiceInfo { const method = this.methods[0], opt = this._transport.mergeOptions(options); return stackIntercept("unary", this._transport, method, opt, input); } + /** + * @generated from protobuf rpc: Createdv2(api.ActorCreatedv2Request) returns (api.ActorCreatedv2Response); + */ + createdv2(input: ActorCreatedv2Request, options?: RpcOptions): UnaryCall { + const method = this.methods[1], opt = this._transport.mergeOptions(options); + return stackIntercept("unary", this._transport, method, opt, input); + } /** * @generated from protobuf rpc: Deleted(api.ActorDeletedRequest) returns (api.ActorDeletedResponse); */ deleted(input: ActorDeletedRequest, options?: RpcOptions): UnaryCall { - const method = this.methods[1], opt = this._transport.mergeOptions(options); + const method = this.methods[2], opt = this._transport.mergeOptions(options); return stackIntercept("unary", this._transport, method, opt, input); } /** * @generated from protobuf rpc: SnapshotCompleted(api.ActorSnapshotCompletedRequest) returns (api.ActorSnapshotCompletedResponse); */ snapshotCompleted(input: ActorSnapshotCompletedRequest, options?: RpcOptions): UnaryCall { - const method = this.methods[2], opt = this._transport.mergeOptions(options); + const method = this.methods[3], opt = this._transport.mergeOptions(options); return stackIntercept("unary", this._transport, method, opt, input); } /** * @generated from protobuf rpc: AttachmentAdded(api.ActorAttachmentAddedRequest) returns (api.ActorAttachmentAddedResponse); */ attachmentAdded(input: ActorAttachmentAddedRequest, options?: RpcOptions): UnaryCall { - const method = this.methods[3], opt = this._transport.mergeOptions(options); + const method = this.methods[4], opt = this._transport.mergeOptions(options); return stackIntercept("unary", this._transport, method, opt, input); } /** * @generated from protobuf rpc: AttachmentRemoved(api.ActorAttachmentRemovedRequest) returns (api.ActorAttachmentRemovedResponse); */ attachmentRemoved(input: ActorAttachmentRemovedRequest, options?: RpcOptions): UnaryCall { - const method = this.methods[4], opt = this._transport.mergeOptions(options); + const method = this.methods[5], opt = this._transport.mergeOptions(options); return stackIntercept("unary", this._transport, method, opt, input); } /** * @generated from protobuf rpc: ClaimAdded(api.ActorClaimAddedRequest) returns (api.ActorClaimAddedResponse); */ claimAdded(input: ActorClaimAddedRequest, options?: RpcOptions): UnaryCall { - const method = this.methods[5], opt = this._transport.mergeOptions(options); + const method = this.methods[6], opt = this._transport.mergeOptions(options); return stackIntercept("unary", this._transport, method, opt, input); } /** * @generated from protobuf rpc: MetaDataUpdated(api.ActorMetaDataUpdatedRequest) returns (api.ActorMetaDataUpdatedResponse); */ metaDataUpdated(input: ActorMetaDataUpdatedRequest, options?: RpcOptions): UnaryCall { - const method = this.methods[6], opt = this._transport.mergeOptions(options); + const method = this.methods[7], opt = this._transport.mergeOptions(options); return stackIntercept("unary", this._transport, method, opt, input); } } diff --git a/actorInput.ts b/actorInput.ts index 1676ae4f..4426c988 100644 --- a/actorInput.ts +++ b/actorInput.ts @@ -178,6 +178,112 @@ export interface ActorCreatedResponse { */ iD?: EntityID; } +/** + * Event Payload + * + * @generated from protobuf message api.ActorCreatedv2Payload + */ +export interface ActorCreatedv2Payload { + /** + * @generated from protobuf field: string Name = 1 [json_name = "Name"]; + */ + name: string; + /** + * @generated from protobuf field: api.IdType IdType = 2 [json_name = "IdType"]; + */ + idType: IdType; + /** + * @generated from protobuf field: repeated api.MetadataElement MetaData = 3 [json_name = "MetaData"]; + */ + metaData: MetadataElement[]; + /** + * @generated from protobuf field: api.Address Address = 4 [json_name = "Address"]; + */ + address?: Address; + /** + * @generated from protobuf field: string AdditionalInformation = 15 [json_name = "AdditionalInformation"]; + */ + additionalInformation: string; + /** + * @generated from protobuf field: api.ActorTypology Typology = 10 [json_name = "Typology"]; + */ + typology: ActorTypology; + /** + * Must be a valid email address + * + * @generated from protobuf field: repeated string Emails = 12 [json_name = "Emails"]; + */ + emails: string[]; + /** + * @generated from protobuf field: repeated string Phones = 13 [json_name = "Phones"]; + */ + phones: string[]; + /** + * Can be used as carrier + * + * @generated from protobuf field: bool IsCarrier = 16 [json_name = "IsCarrier"]; + */ + isCarrier: boolean; + /** + * List of carrier services + * + * @generated from protobuf field: repeated api.CarrierService CarrierServices = 17 [json_name = "CarrierServices"]; + */ + carrierServices: CarrierService[]; +} +/** + * Event message + * + * @generated from protobuf message api.ActorCreatedv2Event + */ +export interface ActorCreatedv2Event { + /** + * @generated from protobuf field: api.EventHeader Header = 1 [json_name = "Header"]; + */ + header?: EventHeader; + /** + * @generated from protobuf field: api.EntityID ID = 2 [json_name = "ID"]; + */ + iD?: EntityID; + /** + * @generated from protobuf field: api.ActorCreatedv2Payload Payload = 3 [json_name = "Payload"]; + */ + payload?: ActorCreatedv2Payload; +} +/** + * API Request + * + * @generated from protobuf message api.ActorCreatedv2Request + */ +export interface ActorCreatedv2Request { + /** + * @generated from protobuf field: api.RequestProjectHeader Header = 1 [json_name = "Header"]; + */ + header?: RequestProjectHeader; + /** + * @generated from protobuf field: api.EntityID ID = 2 [json_name = "ID"]; + */ + iD?: EntityID; + /** + * @generated from protobuf field: api.ActorCreatedv2Payload Payload = 3 [json_name = "Payload"]; + */ + payload?: ActorCreatedv2Payload; +} +/** + * API Response + * + * @generated from protobuf message api.ActorCreatedv2Response + */ +export interface ActorCreatedv2Response { + /** + * @generated from protobuf field: api.ResponseHeader Header = 1 [json_name = "Header"]; + */ + header?: ResponseHeader; + /** + * @generated from protobuf field: api.EntityID ID = 2 [json_name = "ID"]; + */ + iD?: EntityID; +} /** * Event Payload * @@ -899,6 +1005,297 @@ class ActorCreatedResponse$Type extends MessageType { */ export const ActorCreatedResponse = new ActorCreatedResponse$Type(); // @generated message type with reflection information, may provide speed optimized methods +class ActorCreatedv2Payload$Type extends MessageType { + constructor() { + super("api.ActorCreatedv2Payload", [ + { no: 1, name: "Name", kind: "scalar", jsonName: "Name", T: 9 /*ScalarType.STRING*/, options: { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field": { description: "Actor Name" } } }, + { no: 2, name: "IdType", kind: "enum", jsonName: "IdType", T: () => ["api.IdType", IdType], options: { "api.indexationType": { Types: [{ Context: "*", Type: "generatedText" }] }, "api.viewType": { Types: [{ Context: "*", Type: "shortText" }] } } }, + { no: 3, name: "MetaData", kind: "message", jsonName: "MetaData", repeat: 1 /*RepeatType.PACKED*/, T: () => MetadataElement, options: { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field": { description: "Metadata are characteristics specific to the project. They can be of several data form (string, integer, float, boolean or timestamp)" }, "api.metadata": true, "api.aggKey": "Key" } }, + { no: 4, name: "Address", kind: "message", jsonName: "Address", T: () => Address }, + { no: 15, name: "AdditionalInformation", kind: "scalar", jsonName: "AdditionalInformation", T: 9 /*ScalarType.STRING*/ }, + { no: 10, name: "Typology", kind: "enum", jsonName: "Typology", T: () => ["api.ActorTypology", ActorTypology] }, + { no: 12, name: "Emails", kind: "scalar", jsonName: "Emails", repeat: 2 /*RepeatType.UNPACKED*/, T: 9 /*ScalarType.STRING*/, options: { "validate.rules": { repeated: { items: { string: { email: true, ignoreEmpty: true } } } }, "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field": { description: "Must be a valid email address", example: "[\"John.doe@reflex.com\", \"will.smith@reflex.com\"]" } } }, + { no: 13, name: "Phones", kind: "scalar", jsonName: "Phones", repeat: 2 /*RepeatType.UNPACKED*/, T: 9 /*ScalarType.STRING*/, options: { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field": { example: "[\"06 00 00 00 00\", \"+49 00 0000 0000\"]" } } }, + { no: 16, name: "IsCarrier", kind: "scalar", jsonName: "IsCarrier", T: 8 /*ScalarType.BOOL*/, options: { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field": { description: "Can be used as carrier" } } }, + { no: 17, name: "CarrierServices", kind: "message", jsonName: "CarrierServices", repeat: 1 /*RepeatType.PACKED*/, T: () => CarrierService, options: { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field": { description: "List of carrier services" }, "api.aggKey": "ID" } } + ], { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_schema": { jsonSchema: { description: "Event Payload" } }, "api.messageType": "Event", "api.payload": true, "api.inputEvent": "Createdv2" }); + } + create(value?: PartialMessage): ActorCreatedv2Payload { + const message = globalThis.Object.create((this.messagePrototype!)); + message.name = ""; + message.idType = 0; + message.metaData = []; + message.additionalInformation = ""; + message.typology = 0; + message.emails = []; + message.phones = []; + message.isCarrier = false; + message.carrierServices = []; + if (value !== undefined) + reflectionMergePartial(this, message, value); + return message; + } + internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: ActorCreatedv2Payload): ActorCreatedv2Payload { + let message = target ?? this.create(), end = reader.pos + length; + while (reader.pos < end) { + let [fieldNo, wireType] = reader.tag(); + switch (fieldNo) { + case /* string Name = 1 [json_name = "Name"];*/ 1: + message.name = reader.string(); + break; + case /* api.IdType IdType = 2 [json_name = "IdType"];*/ 2: + message.idType = reader.int32(); + break; + case /* repeated api.MetadataElement MetaData = 3 [json_name = "MetaData"];*/ 3: + message.metaData.push(MetadataElement.internalBinaryRead(reader, reader.uint32(), options)); + break; + case /* api.Address Address = 4 [json_name = "Address"];*/ 4: + message.address = Address.internalBinaryRead(reader, reader.uint32(), options, message.address); + break; + case /* string AdditionalInformation = 15 [json_name = "AdditionalInformation"];*/ 15: + message.additionalInformation = reader.string(); + break; + case /* api.ActorTypology Typology = 10 [json_name = "Typology"];*/ 10: + message.typology = reader.int32(); + break; + case /* repeated string Emails = 12 [json_name = "Emails"];*/ 12: + message.emails.push(reader.string()); + break; + case /* repeated string Phones = 13 [json_name = "Phones"];*/ 13: + message.phones.push(reader.string()); + break; + case /* bool IsCarrier = 16 [json_name = "IsCarrier"];*/ 16: + message.isCarrier = reader.bool(); + break; + case /* repeated api.CarrierService CarrierServices = 17 [json_name = "CarrierServices"];*/ 17: + message.carrierServices.push(CarrierService.internalBinaryRead(reader, reader.uint32(), options)); + break; + default: + let u = options.readUnknownField; + if (u === "throw") + throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`); + let d = reader.skip(wireType); + if (u !== false) + (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d); + } + } + return message; + } + internalBinaryWrite(message: ActorCreatedv2Payload, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter { + /* string Name = 1 [json_name = "Name"]; */ + if (message.name !== "") + writer.tag(1, WireType.LengthDelimited).string(message.name); + /* api.IdType IdType = 2 [json_name = "IdType"]; */ + if (message.idType !== 0) + writer.tag(2, WireType.Varint).int32(message.idType); + /* repeated api.MetadataElement MetaData = 3 [json_name = "MetaData"]; */ + for (let i = 0; i < message.metaData.length; i++) + MetadataElement.internalBinaryWrite(message.metaData[i], writer.tag(3, WireType.LengthDelimited).fork(), options).join(); + /* api.Address Address = 4 [json_name = "Address"]; */ + if (message.address) + Address.internalBinaryWrite(message.address, writer.tag(4, WireType.LengthDelimited).fork(), options).join(); + /* string AdditionalInformation = 15 [json_name = "AdditionalInformation"]; */ + if (message.additionalInformation !== "") + writer.tag(15, WireType.LengthDelimited).string(message.additionalInformation); + /* api.ActorTypology Typology = 10 [json_name = "Typology"]; */ + if (message.typology !== 0) + writer.tag(10, WireType.Varint).int32(message.typology); + /* repeated string Emails = 12 [json_name = "Emails"]; */ + for (let i = 0; i < message.emails.length; i++) + writer.tag(12, WireType.LengthDelimited).string(message.emails[i]); + /* repeated string Phones = 13 [json_name = "Phones"]; */ + for (let i = 0; i < message.phones.length; i++) + writer.tag(13, WireType.LengthDelimited).string(message.phones[i]); + /* bool IsCarrier = 16 [json_name = "IsCarrier"]; */ + if (message.isCarrier !== false) + writer.tag(16, WireType.Varint).bool(message.isCarrier); + /* repeated api.CarrierService CarrierServices = 17 [json_name = "CarrierServices"]; */ + for (let i = 0; i < message.carrierServices.length; i++) + CarrierService.internalBinaryWrite(message.carrierServices[i], writer.tag(17, WireType.LengthDelimited).fork(), options).join(); + let u = options.writeUnknownFields; + if (u !== false) + (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer); + return writer; + } +} +/** + * @generated MessageType for protobuf message api.ActorCreatedv2Payload + */ +export const ActorCreatedv2Payload = new ActorCreatedv2Payload$Type(); +// @generated message type with reflection information, may provide speed optimized methods +class ActorCreatedv2Event$Type extends MessageType { + constructor() { + super("api.ActorCreatedv2Event", [ + { no: 1, name: "Header", kind: "message", jsonName: "Header", T: () => EventHeader, options: { "validate.rules": { message: { required: true } } } }, + { no: 2, name: "ID", kind: "message", jsonName: "ID", T: () => EntityID, options: { "validate.rules": { message: { required: true } } } }, + { no: 3, name: "Payload", kind: "message", jsonName: "Payload", T: () => ActorCreatedv2Payload, options: { "validate.rules": { message: { required: true } } } } + ], { "api.messageType": "Event", "api.inputEvent": "Createdv2" }); + } + create(value?: PartialMessage): ActorCreatedv2Event { + const message = globalThis.Object.create((this.messagePrototype!)); + if (value !== undefined) + reflectionMergePartial(this, message, value); + return message; + } + internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: ActorCreatedv2Event): ActorCreatedv2Event { + let message = target ?? this.create(), end = reader.pos + length; + while (reader.pos < end) { + let [fieldNo, wireType] = reader.tag(); + switch (fieldNo) { + case /* api.EventHeader Header = 1 [json_name = "Header"];*/ 1: + message.header = EventHeader.internalBinaryRead(reader, reader.uint32(), options, message.header); + break; + case /* api.EntityID ID = 2 [json_name = "ID"];*/ 2: + message.iD = EntityID.internalBinaryRead(reader, reader.uint32(), options, message.iD); + break; + case /* api.ActorCreatedv2Payload Payload = 3 [json_name = "Payload"];*/ 3: + message.payload = ActorCreatedv2Payload.internalBinaryRead(reader, reader.uint32(), options, message.payload); + break; + default: + let u = options.readUnknownField; + if (u === "throw") + throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`); + let d = reader.skip(wireType); + if (u !== false) + (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d); + } + } + return message; + } + internalBinaryWrite(message: ActorCreatedv2Event, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter { + /* api.EventHeader Header = 1 [json_name = "Header"]; */ + if (message.header) + EventHeader.internalBinaryWrite(message.header, writer.tag(1, WireType.LengthDelimited).fork(), options).join(); + /* api.EntityID ID = 2 [json_name = "ID"]; */ + if (message.iD) + EntityID.internalBinaryWrite(message.iD, writer.tag(2, WireType.LengthDelimited).fork(), options).join(); + /* api.ActorCreatedv2Payload Payload = 3 [json_name = "Payload"]; */ + if (message.payload) + ActorCreatedv2Payload.internalBinaryWrite(message.payload, writer.tag(3, WireType.LengthDelimited).fork(), options).join(); + let u = options.writeUnknownFields; + if (u !== false) + (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer); + return writer; + } +} +/** + * @generated MessageType for protobuf message api.ActorCreatedv2Event + */ +export const ActorCreatedv2Event = new ActorCreatedv2Event$Type(); +// @generated message type with reflection information, may provide speed optimized methods +class ActorCreatedv2Request$Type extends MessageType { + constructor() { + super("api.ActorCreatedv2Request", [ + { no: 1, name: "Header", kind: "message", jsonName: "Header", T: () => RequestProjectHeader, options: { "validate.rules": { message: { required: true } } } }, + { no: 2, name: "ID", kind: "message", jsonName: "ID", T: () => EntityID, options: { "validate.rules": { message: { required: true } } } }, + { no: 3, name: "Payload", kind: "message", jsonName: "Payload", T: () => ActorCreatedv2Payload, options: { "validate.rules": { message: { required: true } } } } + ], { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_schema": { jsonSchema: { required: ["Header", "ID", "Payload"] } }, "api.messageType": "Request", "api.inputEvent": "Createdv2" }); + } + create(value?: PartialMessage): ActorCreatedv2Request { + const message = globalThis.Object.create((this.messagePrototype!)); + if (value !== undefined) + reflectionMergePartial(this, message, value); + return message; + } + internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: ActorCreatedv2Request): ActorCreatedv2Request { + let message = target ?? this.create(), end = reader.pos + length; + while (reader.pos < end) { + let [fieldNo, wireType] = reader.tag(); + switch (fieldNo) { + case /* api.RequestProjectHeader Header = 1 [json_name = "Header"];*/ 1: + message.header = RequestProjectHeader.internalBinaryRead(reader, reader.uint32(), options, message.header); + break; + case /* api.EntityID ID = 2 [json_name = "ID"];*/ 2: + message.iD = EntityID.internalBinaryRead(reader, reader.uint32(), options, message.iD); + break; + case /* api.ActorCreatedv2Payload Payload = 3 [json_name = "Payload"];*/ 3: + message.payload = ActorCreatedv2Payload.internalBinaryRead(reader, reader.uint32(), options, message.payload); + break; + default: + let u = options.readUnknownField; + if (u === "throw") + throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`); + let d = reader.skip(wireType); + if (u !== false) + (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d); + } + } + return message; + } + internalBinaryWrite(message: ActorCreatedv2Request, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter { + /* api.RequestProjectHeader Header = 1 [json_name = "Header"]; */ + if (message.header) + RequestProjectHeader.internalBinaryWrite(message.header, writer.tag(1, WireType.LengthDelimited).fork(), options).join(); + /* api.EntityID ID = 2 [json_name = "ID"]; */ + if (message.iD) + EntityID.internalBinaryWrite(message.iD, writer.tag(2, WireType.LengthDelimited).fork(), options).join(); + /* api.ActorCreatedv2Payload Payload = 3 [json_name = "Payload"]; */ + if (message.payload) + ActorCreatedv2Payload.internalBinaryWrite(message.payload, writer.tag(3, WireType.LengthDelimited).fork(), options).join(); + let u = options.writeUnknownFields; + if (u !== false) + (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer); + return writer; + } +} +/** + * @generated MessageType for protobuf message api.ActorCreatedv2Request + */ +export const ActorCreatedv2Request = new ActorCreatedv2Request$Type(); +// @generated message type with reflection information, may provide speed optimized methods +class ActorCreatedv2Response$Type extends MessageType { + constructor() { + super("api.ActorCreatedv2Response", [ + { no: 1, name: "Header", kind: "message", jsonName: "Header", T: () => ResponseHeader }, + { no: 2, name: "ID", kind: "message", jsonName: "ID", T: () => EntityID } + ], { "api.messageType": "Response", "api.inputEvent": "Createdv2" }); + } + create(value?: PartialMessage): ActorCreatedv2Response { + const message = globalThis.Object.create((this.messagePrototype!)); + if (value !== undefined) + reflectionMergePartial(this, message, value); + return message; + } + internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: ActorCreatedv2Response): ActorCreatedv2Response { + let message = target ?? this.create(), end = reader.pos + length; + while (reader.pos < end) { + let [fieldNo, wireType] = reader.tag(); + switch (fieldNo) { + case /* api.ResponseHeader Header = 1 [json_name = "Header"];*/ 1: + message.header = ResponseHeader.internalBinaryRead(reader, reader.uint32(), options, message.header); + break; + case /* api.EntityID ID = 2 [json_name = "ID"];*/ 2: + message.iD = EntityID.internalBinaryRead(reader, reader.uint32(), options, message.iD); + break; + default: + let u = options.readUnknownField; + if (u === "throw") + throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`); + let d = reader.skip(wireType); + if (u !== false) + (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d); + } + } + return message; + } + internalBinaryWrite(message: ActorCreatedv2Response, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter { + /* api.ResponseHeader Header = 1 [json_name = "Header"]; */ + if (message.header) + ResponseHeader.internalBinaryWrite(message.header, writer.tag(1, WireType.LengthDelimited).fork(), options).join(); + /* api.EntityID ID = 2 [json_name = "ID"]; */ + if (message.iD) + EntityID.internalBinaryWrite(message.iD, writer.tag(2, WireType.LengthDelimited).fork(), options).join(); + let u = options.writeUnknownFields; + if (u !== false) + (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer); + return writer; + } +} +/** + * @generated MessageType for protobuf message api.ActorCreatedv2Response + */ +export const ActorCreatedv2Response = new ActorCreatedv2Response$Type(); +// @generated message type with reflection information, may provide speed optimized methods class ActorDeletedPayload$Type extends MessageType { constructor() { super("api.ActorDeletedPayload", [], { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_schema": { jsonSchema: { description: "Event Payload" } }, "api.messageType": "Event", "api.payload": true, "api.inputEvent": "Deleted" }); @@ -2212,7 +2609,8 @@ export const ActorMetaDataUpdatedResponse = new ActorMetaDataUpdatedResponse$Typ * @generated ServiceType for protobuf service api.ActorInputAPI */ export const ActorInputAPI = new ServiceType("api.ActorInputAPI", [ - { name: "Created", options: { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_operation": { tags: ["Actor Inputs"], description: "An Actor has been created. This is called from Reflex Platform Admin service to share the Organisation actors." }, "api.rscType": "Project", "api.roles": "Platform.Project-Input", "google.api.method_visibility": { restriction: "PUBLIC" } }, I: ActorCreatedRequest, O: ActorCreatedResponse }, + { name: "Created", options: { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_operation": { tags: ["Actor Inputs"], description: "Prefer Createdv2 API usage instead." }, "api.rscType": "Project", "api.roles": "Platform.Project-Input", "google.api.method_visibility": { restriction: "PUBLIC" } }, I: ActorCreatedRequest, O: ActorCreatedResponse }, + { name: "Createdv2", options: { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_operation": { tags: ["Actor Inputs"], description: "An Actor has been created." }, "api.rscType": "Project", "api.roles": "Platform.Project-Input", "google.api.method_visibility": { restriction: "PUBLIC" } }, I: ActorCreatedv2Request, O: ActorCreatedv2Response }, { name: "Deleted", options: { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_operation": { tags: ["Actor Inputs"], description: "An Actor has been deleted. This is called from Reflex Platform Admin service to share the Organisation actors." }, "api.rscType": "Project", "api.roles": "Platform.Project-Input", "google.api.method_visibility": { restriction: "PUBLIC" } }, I: ActorDeletedRequest, O: ActorDeletedResponse }, { name: "SnapshotCompleted", options: { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_operation": { tags: ["Actor Inputs"], description: "A snapshot has been completed on this actor. This is called from a WMS to inform that all Stock snapshot event have been sent." }, "api.rscType": "Project", "api.roles": "Platform.Project-Input", "google.api.method_visibility": { restriction: "PUBLIC" } }, I: ActorSnapshotCompletedRequest, O: ActorSnapshotCompletedResponse }, { name: "AttachmentAdded", options: { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_operation": { tags: ["Actor Inputs"], description: "An attachment is added for the Actor." }, "api.rscType": "Project", "api.roles": "Platform.Project-Attachment", "api.platformReserved": true, "google.api.method_visibility": { restriction: "INTERNAL" } }, I: ActorAttachmentAddedRequest, O: ActorAttachmentAddedResponse }, diff --git a/package.json b/package.json index 8ac5cbe6..71cddbdf 100644 --- a/package.json +++ b/package.json @@ -1,6 +1,6 @@ { "name": "@reflex-platform/npm-core-sdk", - "version": "1.10.0-SNAPSHOT-250320102853", + "version": "1.10.0-SNAPSHOT-250320110813", "description": "npm libs from core model proto files", "homepage": "", "main": "index.ts",