From 52382a9fd1e192d0e74e29b97c695b11f873925f Mon Sep 17 00:00:00 2001 From: ci core model Date: Wed, 18 Feb 2026 15:36:37 +0000 Subject: [PATCH] Latest generation --- api.client.ts | 21 +++++++++-- api.ts | 100 ++++++++++++++++++++++++++++++++++++++++++++++++++ package.json | 2 +- 3 files changed, 118 insertions(+), 5 deletions(-) diff --git a/api.client.ts b/api.client.ts index b1409ee..ba91e83 100644 --- a/api.client.ts +++ b/api.client.ts @@ -12,6 +12,8 @@ import type { CreateScopeResult } from "./api"; import type { CreateScopeRequest } from "./api"; import type { RegisterPackageResult } from "./api"; import type { RegisterPackageRequest } from "./api"; +import type { SynchronizeUserRPTsResponse } from "./api"; +import type { SynchronizeUserRPTsRequest } from "./api"; import type { ListUserRPTsResponse } from "./api"; import type { ListUserRPTsRequest } from "./api"; import type { ListUserUIPermissionsResult } from "./api"; @@ -43,6 +45,10 @@ export interface IAPIServiceClient { * @generated from protobuf rpc: ListUserRPTs */ listUserRPTs(input: ListUserRPTsRequest, options?: RpcOptions): UnaryCall; + /** + * @generated from protobuf rpc: SynchronizeUserRPTs + */ + synchronizeUserRPTs(input: SynchronizeUserRPTsRequest, options?: RpcOptions): UnaryCall; /** * @generated from protobuf rpc: RegisterPackage */ @@ -97,32 +103,39 @@ export class APIServiceClient implements IAPIServiceClient, ServiceInfo { const method = this.methods[3], opt = this._transport.mergeOptions(options); return stackIntercept("unary", this._transport, method, opt, input); } + /** + * @generated from protobuf rpc: SynchronizeUserRPTs + */ + synchronizeUserRPTs(input: SynchronizeUserRPTsRequest, options?: RpcOptions): UnaryCall { + const method = this.methods[4], opt = this._transport.mergeOptions(options); + return stackIntercept("unary", this._transport, method, opt, input); + } /** * @generated from protobuf rpc: RegisterPackage */ registerPackage(input: RegisterPackageRequest, 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: CreateScope */ createScope(input: CreateScopeRequest, 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: DeleteScope */ deleteScope(input: DeleteScopeRequest, 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); } /** * @generated from protobuf rpc: CleanScope */ cleanScope(input: CleanScopeRequest, options?: RpcOptions): UnaryCall { - const method = this.methods[7], opt = this._transport.mergeOptions(options); + const method = this.methods[8], opt = this._transport.mergeOptions(options); return stackIntercept("unary", this._transport, method, opt, input); } } diff --git a/api.ts b/api.ts index 3e4dbcd..a80acda 100644 --- a/api.ts +++ b/api.ts @@ -235,6 +235,20 @@ export interface ListUserRPTsResponse { */ RPTs: UserRPT[]; } +/** + * @generated from protobuf message api.SynchronizeUserRPTsRequest + */ +export interface SynchronizeUserRPTsRequest { + /** + * @generated from protobuf field: string UserID = 1 + */ + UserID: string; +} +/** + * @generated from protobuf message api.SynchronizeUserRPTsResponse + */ +export interface SynchronizeUserRPTsResponse { +} // @generated message type with reflection information, may provide speed optimized methods class GetPermissionsRequest$Type extends MessageType { constructor() { @@ -1146,6 +1160,91 @@ class ListUserRPTsResponse$Type extends MessageType { * @generated MessageType for protobuf message api.ListUserRPTsResponse */ export const ListUserRPTsResponse = new ListUserRPTsResponse$Type(); +// @generated message type with reflection information, may provide speed optimized methods +class SynchronizeUserRPTsRequest$Type extends MessageType { + constructor() { + super("api.SynchronizeUserRPTsRequest", [ + { no: 1, name: "UserID", kind: "scalar", localName: "UserID", jsonName: "UserID", T: 9 /*ScalarType.STRING*/, options: { "validate.rules": { string: { minLen: "1" } } } } + ]); + } + create(value?: PartialMessage): SynchronizeUserRPTsRequest { + const message = globalThis.Object.create((this.messagePrototype!)); + message.UserID = ""; + if (value !== undefined) + reflectionMergePartial(this, message, value); + return message; + } + internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: SynchronizeUserRPTsRequest): SynchronizeUserRPTsRequest { + let message = target ?? this.create(), end = reader.pos + length; + while (reader.pos < end) { + let [fieldNo, wireType] = reader.tag(); + switch (fieldNo) { + case /* string UserID */ 1: + message.UserID = reader.string(); + 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: SynchronizeUserRPTsRequest, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter { + /* string UserID = 1; */ + if (message.UserID !== "") + writer.tag(1, WireType.LengthDelimited).string(message.UserID); + let u = options.writeUnknownFields; + if (u !== false) + (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer); + return writer; + } +} +/** + * @generated MessageType for protobuf message api.SynchronizeUserRPTsRequest + */ +export const SynchronizeUserRPTsRequest = new SynchronizeUserRPTsRequest$Type(); +// @generated message type with reflection information, may provide speed optimized methods +class SynchronizeUserRPTsResponse$Type extends MessageType { + constructor() { + super("api.SynchronizeUserRPTsResponse", []); + } + create(value?: PartialMessage): SynchronizeUserRPTsResponse { + const message = globalThis.Object.create((this.messagePrototype!)); + if (value !== undefined) + reflectionMergePartial(this, message, value); + return message; + } + internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: SynchronizeUserRPTsResponse): SynchronizeUserRPTsResponse { + let message = target ?? this.create(), end = reader.pos + length; + while (reader.pos < end) { + let [fieldNo, wireType] = reader.tag(); + switch (fieldNo) { + 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: SynchronizeUserRPTsResponse, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter { + let u = options.writeUnknownFields; + if (u !== false) + (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer); + return writer; + } +} +/** + * @generated MessageType for protobuf message api.SynchronizeUserRPTsResponse + */ +export const SynchronizeUserRPTsResponse = new SynchronizeUserRPTsResponse$Type(); /** * @generated ServiceType for protobuf service api.APIService */ @@ -1154,6 +1253,7 @@ export const APIService = new ServiceType("api.APIService", [ { name: "GetUIPermissions", options: { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_operation": { tags: ["APIs"], description: "Returns the available UI permissions" }, "api.rscType": "Platform", "api.roles": "Platform.Permission", "google.api.method_visibility": { restriction: "INTERNAL" } }, I: GetUIPermissionsRequest, O: GetUIPermissionsResult }, { name: "ListUserUIPermissions", options: { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_operation": { tags: ["Permissions"], description: "List the user's active UI permissions" }, "api.rscType": "Platform", "api.roles": "", "google.api.method_visibility": { restriction: "SDK" } }, I: ListUserUIPermissionsRequest, O: ListUserUIPermissionsResult }, { name: "ListUserRPTs", options: { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_operation": { tags: ["Permissions"], description: "List the user's stored RPTs" }, "api.rscType": "Platform", "api.roles": "Platform.Permission", "google.api.method_visibility": { restriction: "INTERNAL" } }, I: ListUserRPTsRequest, O: ListUserRPTsResponse }, + { name: "SynchronizeUserRPTs", options: { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_operation": { tags: ["Permissions"], description: "Synchronize the user's RPTs with UMA. This will update the user's RPTs to reflect the current permissions stored in the platform. This API is used by the platform to manually trigger a synchronization of the user's RPTs with UMA." }, "api.rscType": "Platform", "api.roles": "Platform.Permission", "google.api.method_visibility": { restriction: "INTERNAL" } }, I: SynchronizeUserRPTsRequest, O: SynchronizeUserRPTsResponse }, { name: "RegisterPackage", options: { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_operation": { tags: ["APIs"], description: "Register a package with its set of Clients and their APIs" }, "api.rscType": "Platform", "api.roles": "Platform.PackageInit", "google.api.method_visibility": { restriction: "INTERNAL" } }, I: RegisterPackageRequest, O: RegisterPackageResult }, { name: "CreateScope", options: { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_operation": { tags: ["APIs"], description: "Create a new scope. This API is used by the platform to create scopes for specific resources (e.g. projects). Static scopes are created by the platform through the RegisterModule API and are based on a static list." }, "api.rscType": "Platform", "api.roles": "Platform.Scope", "google.api.method_visibility": { restriction: "INTERNAL" } }, I: CreateScopeRequest, O: CreateScopeResult }, { name: "DeleteScope", options: { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_operation": { tags: ["APIs"], description: "Delete a scope" }, "api.rscType": "Platform", "api.roles": "Platform.Scope", "google.api.method_visibility": { restriction: "INTERNAL" } }, I: DeleteScopeRequest, O: DeleteScopeResult }, diff --git a/package.json b/package.json index 572ea95..6e22e63 100644 --- a/package.json +++ b/package.json @@ -1,6 +1,6 @@ { "name": "@reflex-platform/npm-core-sdk", - "version": "1.13.0-SNAPSHOT-260218103017", + "version": "1.13.0-SNAPSHOT-260218153552", "description": "npm libs from core model proto files", "homepage": "", "main": "index.ts",