Latest generation

attachmentType.client.ts

@@ -4,6 +4,12 @@
 import type { RpcTransport } from "@protobuf-ts/runtime-rpc";
 import type { ServiceInfo } from "@protobuf-ts/runtime-rpc";
 import { AttachmentTypeService } from "./attachmentType";
+import type { DeleteAllAttachmentsTypeOnSiteRequest } from "./attachmentType";
+import type { DeleteAttachmentTypeOnSiteRequest } from "./attachmentType";
+import type { UpdateAttachmentTypeOnSiteRequest } from "./attachmentType";
+import type { ListAttachmentTypeOnSiteRequest } from "./attachmentType";
+import type { GetAttachmentTypeOnSiteRequest } from "./attachmentType";
+import type { CreateAttachmentTypeOnSiteRequest } from "./attachmentType";
 import type { DeleteAllAttachmentsTypeResponse } from "./attachmentType";
 import type { DeleteAllAttachmentsTypeRequest } from "./attachmentType";
 import type { DeleteAttachmentTypeResponse } from "./attachmentType";
@@ -47,6 +53,32 @@ export interface IAttachmentTypeServiceClient {
      * @generated from protobuf rpc: DeleteAll
      */
     deleteAll(input: DeleteAllAttachmentsTypeRequest, options?: RpcOptions): UnaryCall<DeleteAllAttachmentsTypeRequest, DeleteAllAttachmentsTypeResponse>;
+    // On Site
+
+    /**
+     * @generated from protobuf rpc: CreateOnSite
+     */
+    createOnSite(input: CreateAttachmentTypeOnSiteRequest, options?: RpcOptions): UnaryCall<CreateAttachmentTypeOnSiteRequest, CreateAttachmentTypeResponse>;
+    /**
+     * @generated from protobuf rpc: GetOnSite
+     */
+    getOnSite(input: GetAttachmentTypeOnSiteRequest, options?: RpcOptions): UnaryCall<GetAttachmentTypeOnSiteRequest, GetAttachmentTypeResponse>;
+    /**
+     * @generated from protobuf rpc: ListOnSite
+     */
+    listOnSite(input: ListAttachmentTypeOnSiteRequest, options?: RpcOptions): UnaryCall<ListAttachmentTypeOnSiteRequest, ListAttachmentTypeResponse>;
+    /**
+     * @generated from protobuf rpc: UpdateOnSite
+     */
+    updateOnSite(input: UpdateAttachmentTypeOnSiteRequest, options?: RpcOptions): UnaryCall<UpdateAttachmentTypeOnSiteRequest, UpdateAttachmentTypeResponse>;
+    /**
+     * @generated from protobuf rpc: DeleteOnSite
+     */
+    deleteOnSite(input: DeleteAttachmentTypeOnSiteRequest, options?: RpcOptions): UnaryCall<DeleteAttachmentTypeOnSiteRequest, DeleteAttachmentTypeResponse>;
+    /**
+     * @generated from protobuf rpc: DeleteAllOnSite
+     */
+    deleteAllOnSite(input: DeleteAllAttachmentsTypeOnSiteRequest, options?: RpcOptions): UnaryCall<DeleteAllAttachmentsTypeOnSiteRequest, DeleteAllAttachmentsTypeResponse>;
 }
 /**
  * @generated from protobuf service api.AttachmentTypeService
@@ -99,4 +131,48 @@ export class AttachmentTypeServiceClient implements IAttachmentTypeServiceClient
         const method = this.methods[5], opt = this._transport.mergeOptions(options);
         return stackIntercept<DeleteAllAttachmentsTypeRequest, DeleteAllAttachmentsTypeResponse>("unary", this._transport, method, opt, input);
     }
+    // On Site
+
+    /**
+     * @generated from protobuf rpc: CreateOnSite
+     */
+    createOnSite(input: CreateAttachmentTypeOnSiteRequest, options?: RpcOptions): UnaryCall<CreateAttachmentTypeOnSiteRequest, CreateAttachmentTypeResponse> {
+        const method = this.methods[6], opt = this._transport.mergeOptions(options);
+        return stackIntercept<CreateAttachmentTypeOnSiteRequest, CreateAttachmentTypeResponse>("unary", this._transport, method, opt, input);
+    }
+    /**
+     * @generated from protobuf rpc: GetOnSite
+     */
+    getOnSite(input: GetAttachmentTypeOnSiteRequest, options?: RpcOptions): UnaryCall<GetAttachmentTypeOnSiteRequest, GetAttachmentTypeResponse> {
+        const method = this.methods[7], opt = this._transport.mergeOptions(options);
+        return stackIntercept<GetAttachmentTypeOnSiteRequest, GetAttachmentTypeResponse>("unary", this._transport, method, opt, input);
+    }
+    /**
+     * @generated from protobuf rpc: ListOnSite
+     */
+    listOnSite(input: ListAttachmentTypeOnSiteRequest, options?: RpcOptions): UnaryCall<ListAttachmentTypeOnSiteRequest, ListAttachmentTypeResponse> {
+        const method = this.methods[8], opt = this._transport.mergeOptions(options);
+        return stackIntercept<ListAttachmentTypeOnSiteRequest, ListAttachmentTypeResponse>("unary", this._transport, method, opt, input);
+    }
+    /**
+     * @generated from protobuf rpc: UpdateOnSite
+     */
+    updateOnSite(input: UpdateAttachmentTypeOnSiteRequest, options?: RpcOptions): UnaryCall<UpdateAttachmentTypeOnSiteRequest, UpdateAttachmentTypeResponse> {
+        const method = this.methods[9], opt = this._transport.mergeOptions(options);
+        return stackIntercept<UpdateAttachmentTypeOnSiteRequest, UpdateAttachmentTypeResponse>("unary", this._transport, method, opt, input);
+    }
+    /**
+     * @generated from protobuf rpc: DeleteOnSite
+     */
+    deleteOnSite(input: DeleteAttachmentTypeOnSiteRequest, options?: RpcOptions): UnaryCall<DeleteAttachmentTypeOnSiteRequest, DeleteAttachmentTypeResponse> {
+        const method = this.methods[10], opt = this._transport.mergeOptions(options);
+        return stackIntercept<DeleteAttachmentTypeOnSiteRequest, DeleteAttachmentTypeResponse>("unary", this._transport, method, opt, input);
+    }
+    /**
+     * @generated from protobuf rpc: DeleteAllOnSite
+     */
+    deleteAllOnSite(input: DeleteAllAttachmentsTypeOnSiteRequest, options?: RpcOptions): UnaryCall<DeleteAllAttachmentsTypeOnSiteRequest, DeleteAllAttachmentsTypeResponse> {
+        const method = this.methods[11], opt = this._transport.mergeOptions(options);
+        return stackIntercept<DeleteAllAttachmentsTypeOnSiteRequest, DeleteAllAttachmentsTypeResponse>("unary", this._transport, method, opt, input);
+    }
 }

attachmentType.ts

@@ -12,6 +12,7 @@ import type { PartialMessage } from "@protobuf-ts/runtime";
 import { reflectionMergePartial } from "@protobuf-ts/runtime";
 import { MessageType } from "@protobuf-ts/runtime";
 import { AttachmentType } from "./shared";
+import { RequestSiteHeader } from "./shared";
 import { SharePolicy } from "./shared";
 import { EntityType } from "./shared";
 import { RequestProjectHeader } from "./shared";
@@ -52,6 +53,39 @@ export interface CreateAttachmentTypeRequest {
      */
     ViewerRoles: string[];
 }
+/**
+ * @generated from protobuf message api.CreateAttachmentTypeOnSiteRequest
+ */
+export interface CreateAttachmentTypeOnSiteRequest {
+    /**
+     * @generated from protobuf field: api.RequestSiteHeader Header = 1
+     */
+    Header?: RequestSiteHeader;
+    /**
+     * @generated from protobuf field: string Code = 2
+     */
+    Code: string;
+    /**
+     * @generated from protobuf field: api.EntityType Entity = 3
+     */
+    Entity: EntityType;
+    /**
+     * @generated from protobuf field: string Label = 4
+     */
+    Label: string;
+    /**
+     * @generated from protobuf field: api.SharePolicy SharePolicy = 5
+     */
+    SharePolicy: SharePolicy;
+    /**
+     * @generated from protobuf field: repeated string ManagerRoles = 6
+     */
+    ManagerRoles: string[];
+    /**
+     * @generated from protobuf field: repeated string ViewerRoles = 7
+     */
+    ViewerRoles: string[];
+}
 /**
  * @generated from protobuf message api.CreateAttachmentTypeResponse
  */
@@ -86,6 +120,29 @@ export interface GetAttachmentTypeRequest {
      */
     ID: string;
 }
+/**
+ * @generated from protobuf message api.GetAttachmentTypeOnSiteRequest
+ */
+export interface GetAttachmentTypeOnSiteRequest {
+    /**
+     * @generated from protobuf field: api.RequestSiteHeader Header = 1
+     */
+    Header?: RequestSiteHeader;
+    /**
+     * @deprecated
+     * @generated from protobuf field: string Code = 2 [deprecated = true]
+     */
+    Code: string;
+    /**
+     * @deprecated
+     * @generated from protobuf field: api.EntityType Entity = 3 [deprecated = true]
+     */
+    Entity: EntityType;
+    /**
+     * @generated from protobuf field: string ID = 4
+     */
+    ID: string;
+}
 /**
  * @generated from protobuf message api.GetAttachmentTypeResponse
  */
@@ -110,6 +167,19 @@ export interface ListAttachmentTypeRequest {
      */
     Entity: EntityType;
 }
+/**
+ * @generated from protobuf message api.ListAttachmentTypeOnSiteRequest
+ */
+export interface ListAttachmentTypeOnSiteRequest {
+    /**
+     * @generated from protobuf field: api.RequestSiteHeader Header = 1
+     */
+    Header?: RequestSiteHeader;
+    /**
+     * @generated from protobuf field: api.EntityType Entity = 2
+     */
+    Entity: EntityType;
+}
 /**
  * @generated from protobuf message api.ListAttachmentTypeResponse
  */
@@ -160,6 +230,45 @@ export interface UpdateAttachmentTypeRequest {
      */
     ViewerRoles: string[];
 }
+/**
+ * @generated from protobuf message api.UpdateAttachmentTypeOnSiteRequest
+ */
+export interface UpdateAttachmentTypeOnSiteRequest {
+    /**
+     * @generated from protobuf field: api.RequestSiteHeader Header = 1
+     */
+    Header?: RequestSiteHeader;
+    /**
+     * @deprecated
+     * @generated from protobuf field: string Code = 2 [deprecated = true]
+     */
+    Code: string;
+    /**
+     * @deprecated
+     * @generated from protobuf field: api.EntityType Entity = 3 [deprecated = true]
+     */
+    Entity: EntityType;
+    /**
+     * @generated from protobuf field: string Label = 4
+     */
+    Label: string;
+    /**
+     * @generated from protobuf field: api.SharePolicy SharePolicy = 5
+     */
+    SharePolicy: SharePolicy;
+    /**
+     * @generated from protobuf field: string ID = 6
+     */
+    ID: string;
+    /**
+     * @generated from protobuf field: repeated string ManagerRoles = 7
+     */
+    ManagerRoles: string[];
+    /**
+     * @generated from protobuf field: repeated string ViewerRoles = 8
+     */
+    ViewerRoles: string[];
+}
 /**
  * @generated from protobuf message api.UpdateAttachmentTypeResponse
  */
@@ -194,6 +303,29 @@ export interface DeleteAttachmentTypeRequest {
      */
     ID: string;
 }
+/**
+ * @generated from protobuf message api.DeleteAttachmentTypeOnSiteRequest
+ */
+export interface DeleteAttachmentTypeOnSiteRequest {
+    /**
+     * @generated from protobuf field: api.RequestSiteHeader Header = 1
+     */
+    Header?: RequestSiteHeader;
+    /**
+     * @deprecated
+     * @generated from protobuf field: string Code = 2 [deprecated = true]
+     */
+    Code: string;
+    /**
+     * @deprecated
+     * @generated from protobuf field: api.EntityType Entity = 3 [deprecated = true]
+     */
+    Entity: EntityType;
+    /**
+     * @generated from protobuf field: string ID = 4
+     */
+    ID: string;
+}
 /**
  * @generated from protobuf message api.DeleteAttachmentTypeResponse
  */
@@ -208,6 +340,15 @@ export interface DeleteAllAttachmentsTypeRequest {
      */
     Header?: RequestProjectHeader;
 }
+/**
+ * @generated from protobuf message api.DeleteAllAttachmentsTypeOnSiteRequest
+ */
+export interface DeleteAllAttachmentsTypeOnSiteRequest {
+    /**
+     * @generated from protobuf field: api.RequestSiteHeader Header = 1
+     */
+    Header?: RequestSiteHeader;
+}
 /**
  * @generated from protobuf message api.DeleteAllAttachmentsTypeResponse
  */
@@ -308,6 +449,100 @@ class CreateAttachmentTypeRequest$Type extends MessageType<CreateAttachmentTypeR
  */
 export const CreateAttachmentTypeRequest = new CreateAttachmentTypeRequest$Type();
 // @generated message type with reflection information, may provide speed optimized methods
+class CreateAttachmentTypeOnSiteRequest$Type extends MessageType<CreateAttachmentTypeOnSiteRequest> {
+    constructor() {
+        super("api.CreateAttachmentTypeOnSiteRequest", [
+            { no: 1, name: "Header", kind: "message", localName: "Header", jsonName: "Header", T: () => RequestSiteHeader, options: { "validate.rules": { message: { required: true } } } },
+            { no: 2, name: "Code", kind: "scalar", localName: "Code", jsonName: "Code", T: 9 /*ScalarType.STRING*/, options: { "validate.rules": { string: { minLen: "1", pattern: "^[a-zA-Z0-9-]+$" } }, "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field": { pattern: "^[a-zA-Z0-9-]+$" } } },
+            { no: 3, name: "Entity", kind: "enum", localName: "Entity", jsonName: "Entity", T: () => ["api.EntityType", EntityType], options: { "validate.rules": { enum: { definedOnly: true } } } },
+            { no: 4, name: "Label", kind: "scalar", localName: "Label", jsonName: "Label", T: 9 /*ScalarType.STRING*/, options: { "validate.rules": { string: { minLen: "1" } } } },
+            { no: 5, name: "SharePolicy", kind: "enum", localName: "SharePolicy", jsonName: "SharePolicy", T: () => ["api.SharePolicy", SharePolicy], options: { "validate.rules": { enum: { definedOnly: true } } } },
+            { no: 6, name: "ManagerRoles", kind: "scalar", localName: "ManagerRoles", jsonName: "ManagerRoles", repeat: 2 /*RepeatType.UNPACKED*/, T: 9 /*ScalarType.STRING*/ },
+            { no: 7, name: "ViewerRoles", kind: "scalar", localName: "ViewerRoles", jsonName: "ViewerRoles", repeat: 2 /*RepeatType.UNPACKED*/, T: 9 /*ScalarType.STRING*/ }
+        ], { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_schema": { jsonSchema: { required: ["Header", "Code", "Entity", "Label", "SharePolicy"] } } });
+    }
+    create(value?: PartialMessage<CreateAttachmentTypeOnSiteRequest>): CreateAttachmentTypeOnSiteRequest {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.Code = "";
+        message.Entity = 0;
+        message.Label = "";
+        message.SharePolicy = 0;
+        message.ManagerRoles = [];
+        message.ViewerRoles = [];
+        if (value !== undefined)
+            reflectionMergePartial<CreateAttachmentTypeOnSiteRequest>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: CreateAttachmentTypeOnSiteRequest): CreateAttachmentTypeOnSiteRequest {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* api.RequestSiteHeader Header */ 1:
+                    message.Header = RequestSiteHeader.internalBinaryRead(reader, reader.uint32(), options, message.Header);
+                    break;
+                case /* string Code */ 2:
+                    message.Code = reader.string();
+                    break;
+                case /* api.EntityType Entity */ 3:
+                    message.Entity = reader.int32();
+                    break;
+                case /* string Label */ 4:
+                    message.Label = reader.string();
+                    break;
+                case /* api.SharePolicy SharePolicy */ 5:
+                    message.SharePolicy = reader.int32();
+                    break;
+                case /* repeated string ManagerRoles */ 6:
+                    message.ManagerRoles.push(reader.string());
+                    break;
+                case /* repeated string ViewerRoles */ 7:
+                    message.ViewerRoles.push(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: CreateAttachmentTypeOnSiteRequest, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* api.RequestSiteHeader Header = 1; */
+        if (message.Header)
+            RequestSiteHeader.internalBinaryWrite(message.Header, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+        /* string Code = 2; */
+        if (message.Code !== "")
+            writer.tag(2, WireType.LengthDelimited).string(message.Code);
+        /* api.EntityType Entity = 3; */
+        if (message.Entity !== 0)
+            writer.tag(3, WireType.Varint).int32(message.Entity);
+        /* string Label = 4; */
+        if (message.Label !== "")
+            writer.tag(4, WireType.LengthDelimited).string(message.Label);
+        /* api.SharePolicy SharePolicy = 5; */
+        if (message.SharePolicy !== 0)
+            writer.tag(5, WireType.Varint).int32(message.SharePolicy);
+        /* repeated string ManagerRoles = 6; */
+        for (let i = 0; i < message.ManagerRoles.length; i++)
+            writer.tag(6, WireType.LengthDelimited).string(message.ManagerRoles[i]);
+        /* repeated string ViewerRoles = 7; */
+        for (let i = 0; i < message.ViewerRoles.length; i++)
+            writer.tag(7, WireType.LengthDelimited).string(message.ViewerRoles[i]);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message api.CreateAttachmentTypeOnSiteRequest
+ */
+export const CreateAttachmentTypeOnSiteRequest = new CreateAttachmentTypeOnSiteRequest$Type();
+// @generated message type with reflection information, may provide speed optimized methods
 class CreateAttachmentTypeResponse$Type extends MessageType<CreateAttachmentTypeResponse> {
     constructor() {
         super("api.CreateAttachmentTypeResponse", [
@@ -424,6 +659,76 @@ class GetAttachmentTypeRequest$Type extends MessageType<GetAttachmentTypeRequest
  */
 export const GetAttachmentTypeRequest = new GetAttachmentTypeRequest$Type();
 // @generated message type with reflection information, may provide speed optimized methods
+class GetAttachmentTypeOnSiteRequest$Type extends MessageType<GetAttachmentTypeOnSiteRequest> {
+    constructor() {
+        super("api.GetAttachmentTypeOnSiteRequest", [
+            { no: 1, name: "Header", kind: "message", localName: "Header", jsonName: "Header", T: () => RequestSiteHeader, options: { "validate.rules": { message: { required: true } } } },
+            { no: 2, name: "Code", kind: "scalar", localName: "Code", jsonName: "Code", T: 9 /*ScalarType.STRING*/, options: { "validate.rules": { string: { pattern: "^[a-zA-Z0-9-]*" } }, "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field": { pattern: "^[a-zA-Z0-9-]*" } } },
+            { no: 3, name: "Entity", kind: "enum", localName: "Entity", jsonName: "Entity", T: () => ["api.EntityType", EntityType], options: { "validate.rules": { enum: { definedOnly: true } } } },
+            { no: 4, name: "ID", kind: "scalar", localName: "ID", jsonName: "ID", T: 9 /*ScalarType.STRING*/, options: { "validate.rules": { string: { pattern: "^[a-zA-Z0-9-]*" } }, "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field": { pattern: "^[a-zA-Z0-9-]*" } } }
+        ], { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_schema": { jsonSchema: { required: ["Header", "Code", "Entity"] } } });
+    }
+    create(value?: PartialMessage<GetAttachmentTypeOnSiteRequest>): GetAttachmentTypeOnSiteRequest {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.Code = "";
+        message.Entity = 0;
+        message.ID = "";
+        if (value !== undefined)
+            reflectionMergePartial<GetAttachmentTypeOnSiteRequest>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: GetAttachmentTypeOnSiteRequest): GetAttachmentTypeOnSiteRequest {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* api.RequestSiteHeader Header */ 1:
+                    message.Header = RequestSiteHeader.internalBinaryRead(reader, reader.uint32(), options, message.Header);
+                    break;
+                case /* string Code = 2 [deprecated = true] */ 2:
+                    message.Code = reader.string();
+                    break;
+                case /* api.EntityType Entity = 3 [deprecated = true] */ 3:
+                    message.Entity = reader.int32();
+                    break;
+                case /* string ID */ 4:
+                    message.ID = 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: GetAttachmentTypeOnSiteRequest, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* api.RequestSiteHeader Header = 1; */
+        if (message.Header)
+            RequestSiteHeader.internalBinaryWrite(message.Header, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+        /* string Code = 2 [deprecated = true]; */
+        if (message.Code !== "")
+            writer.tag(2, WireType.LengthDelimited).string(message.Code);
+        /* api.EntityType Entity = 3 [deprecated = true]; */
+        if (message.Entity !== 0)
+            writer.tag(3, WireType.Varint).int32(message.Entity);
+        /* string ID = 4; */
+        if (message.ID !== "")
+            writer.tag(4, WireType.LengthDelimited).string(message.ID);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message api.GetAttachmentTypeOnSiteRequest
+ */
+export const GetAttachmentTypeOnSiteRequest = new GetAttachmentTypeOnSiteRequest$Type();
+// @generated message type with reflection information, may provide speed optimized methods
 class GetAttachmentTypeResponse$Type extends MessageType<GetAttachmentTypeResponse> {
     constructor() {
         super("api.GetAttachmentTypeResponse", [
@@ -524,6 +829,60 @@ class ListAttachmentTypeRequest$Type extends MessageType<ListAttachmentTypeReque
  */
 export const ListAttachmentTypeRequest = new ListAttachmentTypeRequest$Type();
 // @generated message type with reflection information, may provide speed optimized methods
+class ListAttachmentTypeOnSiteRequest$Type extends MessageType<ListAttachmentTypeOnSiteRequest> {
+    constructor() {
+        super("api.ListAttachmentTypeOnSiteRequest", [
+            { no: 1, name: "Header", kind: "message", localName: "Header", jsonName: "Header", T: () => RequestSiteHeader, options: { "validate.rules": { message: { required: true } } } },
+            { no: 2, name: "Entity", kind: "enum", localName: "Entity", jsonName: "Entity", T: () => ["api.EntityType", EntityType], options: { "validate.rules": { enum: { definedOnly: true } } } }
+        ], { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_schema": { jsonSchema: { required: ["Header"] } } });
+    }
+    create(value?: PartialMessage<ListAttachmentTypeOnSiteRequest>): ListAttachmentTypeOnSiteRequest {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.Entity = 0;
+        if (value !== undefined)
+            reflectionMergePartial<ListAttachmentTypeOnSiteRequest>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: ListAttachmentTypeOnSiteRequest): ListAttachmentTypeOnSiteRequest {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* api.RequestSiteHeader Header */ 1:
+                    message.Header = RequestSiteHeader.internalBinaryRead(reader, reader.uint32(), options, message.Header);
+                    break;
+                case /* api.EntityType Entity */ 2:
+                    message.Entity = reader.int32();
+                    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: ListAttachmentTypeOnSiteRequest, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* api.RequestSiteHeader Header = 1; */
+        if (message.Header)
+            RequestSiteHeader.internalBinaryWrite(message.Header, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+        /* api.EntityType Entity = 2; */
+        if (message.Entity !== 0)
+            writer.tag(2, WireType.Varint).int32(message.Entity);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message api.ListAttachmentTypeOnSiteRequest
+ */
+export const ListAttachmentTypeOnSiteRequest = new ListAttachmentTypeOnSiteRequest$Type();
+// @generated message type with reflection information, may provide speed optimized methods
 class ListAttachmentTypeResponse$Type extends MessageType<ListAttachmentTypeResponse> {
     constructor() {
         super("api.ListAttachmentTypeResponse", [
@@ -673,6 +1032,108 @@ class UpdateAttachmentTypeRequest$Type extends MessageType<UpdateAttachmentTypeR
  */
 export const UpdateAttachmentTypeRequest = new UpdateAttachmentTypeRequest$Type();
 // @generated message type with reflection information, may provide speed optimized methods
+class UpdateAttachmentTypeOnSiteRequest$Type extends MessageType<UpdateAttachmentTypeOnSiteRequest> {
+    constructor() {
+        super("api.UpdateAttachmentTypeOnSiteRequest", [
+            { no: 1, name: "Header", kind: "message", localName: "Header", jsonName: "Header", T: () => RequestSiteHeader, options: { "validate.rules": { message: { required: true } } } },
+            { no: 2, name: "Code", kind: "scalar", localName: "Code", jsonName: "Code", T: 9 /*ScalarType.STRING*/, options: { "validate.rules": { string: { pattern: "^[a-zA-Z0-9-]*" } }, "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field": { pattern: "^[a-zA-Z0-9-]*" } } },
+            { no: 3, name: "Entity", kind: "enum", localName: "Entity", jsonName: "Entity", T: () => ["api.EntityType", EntityType], options: { "validate.rules": { enum: { definedOnly: true } } } },
+            { no: 4, name: "Label", kind: "scalar", localName: "Label", jsonName: "Label", T: 9 /*ScalarType.STRING*/ },
+            { no: 5, name: "SharePolicy", kind: "enum", localName: "SharePolicy", jsonName: "SharePolicy", T: () => ["api.SharePolicy", SharePolicy], options: { "validate.rules": { enum: { definedOnly: true } } } },
+            { no: 6, name: "ID", kind: "scalar", localName: "ID", jsonName: "ID", T: 9 /*ScalarType.STRING*/, options: { "validate.rules": { string: { pattern: "^[a-zA-Z0-9-]*" } }, "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field": { pattern: "^[a-zA-Z0-9-]*" } } },
+            { no: 7, name: "ManagerRoles", kind: "scalar", localName: "ManagerRoles", jsonName: "ManagerRoles", repeat: 2 /*RepeatType.UNPACKED*/, T: 9 /*ScalarType.STRING*/ },
+            { no: 8, name: "ViewerRoles", kind: "scalar", localName: "ViewerRoles", jsonName: "ViewerRoles", repeat: 2 /*RepeatType.UNPACKED*/, T: 9 /*ScalarType.STRING*/ }
+        ], { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_schema": { jsonSchema: { required: ["Header", "Code", "Entity"] } } });
+    }
+    create(value?: PartialMessage<UpdateAttachmentTypeOnSiteRequest>): UpdateAttachmentTypeOnSiteRequest {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.Code = "";
+        message.Entity = 0;
+        message.Label = "";
+        message.SharePolicy = 0;
+        message.ID = "";
+        message.ManagerRoles = [];
+        message.ViewerRoles = [];
+        if (value !== undefined)
+            reflectionMergePartial<UpdateAttachmentTypeOnSiteRequest>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: UpdateAttachmentTypeOnSiteRequest): UpdateAttachmentTypeOnSiteRequest {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* api.RequestSiteHeader Header */ 1:
+                    message.Header = RequestSiteHeader.internalBinaryRead(reader, reader.uint32(), options, message.Header);
+                    break;
+                case /* string Code = 2 [deprecated = true] */ 2:
+                    message.Code = reader.string();
+                    break;
+                case /* api.EntityType Entity = 3 [deprecated = true] */ 3:
+                    message.Entity = reader.int32();
+                    break;
+                case /* string Label */ 4:
+                    message.Label = reader.string();
+                    break;
+                case /* api.SharePolicy SharePolicy */ 5:
+                    message.SharePolicy = reader.int32();
+                    break;
+                case /* string ID */ 6:
+                    message.ID = reader.string();
+                    break;
+                case /* repeated string ManagerRoles */ 7:
+                    message.ManagerRoles.push(reader.string());
+                    break;
+                case /* repeated string ViewerRoles */ 8:
+                    message.ViewerRoles.push(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: UpdateAttachmentTypeOnSiteRequest, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* api.RequestSiteHeader Header = 1; */
+        if (message.Header)
+            RequestSiteHeader.internalBinaryWrite(message.Header, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+        /* string Code = 2 [deprecated = true]; */
+        if (message.Code !== "")
+            writer.tag(2, WireType.LengthDelimited).string(message.Code);
+        /* api.EntityType Entity = 3 [deprecated = true]; */
+        if (message.Entity !== 0)
+            writer.tag(3, WireType.Varint).int32(message.Entity);
+        /* string Label = 4; */
+        if (message.Label !== "")
+            writer.tag(4, WireType.LengthDelimited).string(message.Label);
+        /* api.SharePolicy SharePolicy = 5; */
+        if (message.SharePolicy !== 0)
+            writer.tag(5, WireType.Varint).int32(message.SharePolicy);
+        /* string ID = 6; */
+        if (message.ID !== "")
+            writer.tag(6, WireType.LengthDelimited).string(message.ID);
+        /* repeated string ManagerRoles = 7; */
+        for (let i = 0; i < message.ManagerRoles.length; i++)
+            writer.tag(7, WireType.LengthDelimited).string(message.ManagerRoles[i]);
+        /* repeated string ViewerRoles = 8; */
+        for (let i = 0; i < message.ViewerRoles.length; i++)
+            writer.tag(8, WireType.LengthDelimited).string(message.ViewerRoles[i]);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message api.UpdateAttachmentTypeOnSiteRequest
+ */
+export const UpdateAttachmentTypeOnSiteRequest = new UpdateAttachmentTypeOnSiteRequest$Type();
+// @generated message type with reflection information, may provide speed optimized methods
 class UpdateAttachmentTypeResponse$Type extends MessageType<UpdateAttachmentTypeResponse> {
     constructor() {
         super("api.UpdateAttachmentTypeResponse", [
@@ -789,6 +1250,76 @@ class DeleteAttachmentTypeRequest$Type extends MessageType<DeleteAttachmentTypeR
  */
 export const DeleteAttachmentTypeRequest = new DeleteAttachmentTypeRequest$Type();
 // @generated message type with reflection information, may provide speed optimized methods
+class DeleteAttachmentTypeOnSiteRequest$Type extends MessageType<DeleteAttachmentTypeOnSiteRequest> {
+    constructor() {
+        super("api.DeleteAttachmentTypeOnSiteRequest", [
+            { no: 1, name: "Header", kind: "message", localName: "Header", jsonName: "Header", T: () => RequestSiteHeader, options: { "validate.rules": { message: { required: true } } } },
+            { no: 2, name: "Code", kind: "scalar", localName: "Code", jsonName: "Code", T: 9 /*ScalarType.STRING*/, options: { "validate.rules": { string: { pattern: "^[a-zA-Z0-9-]*" } }, "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field": { pattern: "^[a-zA-Z0-9-]*" } } },
+            { no: 3, name: "Entity", kind: "enum", localName: "Entity", jsonName: "Entity", T: () => ["api.EntityType", EntityType], options: { "validate.rules": { enum: { definedOnly: true } } } },
+            { no: 4, name: "ID", kind: "scalar", localName: "ID", jsonName: "ID", T: 9 /*ScalarType.STRING*/, options: { "validate.rules": { string: { pattern: "^[a-zA-Z0-9-]*" } }, "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field": { pattern: "^[a-zA-Z0-9-]*" } } }
+        ], { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_schema": { jsonSchema: { required: ["Header", "Code", "Entity"] } } });
+    }
+    create(value?: PartialMessage<DeleteAttachmentTypeOnSiteRequest>): DeleteAttachmentTypeOnSiteRequest {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.Code = "";
+        message.Entity = 0;
+        message.ID = "";
+        if (value !== undefined)
+            reflectionMergePartial<DeleteAttachmentTypeOnSiteRequest>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: DeleteAttachmentTypeOnSiteRequest): DeleteAttachmentTypeOnSiteRequest {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* api.RequestSiteHeader Header */ 1:
+                    message.Header = RequestSiteHeader.internalBinaryRead(reader, reader.uint32(), options, message.Header);
+                    break;
+                case /* string Code = 2 [deprecated = true] */ 2:
+                    message.Code = reader.string();
+                    break;
+                case /* api.EntityType Entity = 3 [deprecated = true] */ 3:
+                    message.Entity = reader.int32();
+                    break;
+                case /* string ID */ 4:
+                    message.ID = 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: DeleteAttachmentTypeOnSiteRequest, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* api.RequestSiteHeader Header = 1; */
+        if (message.Header)
+            RequestSiteHeader.internalBinaryWrite(message.Header, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+        /* string Code = 2 [deprecated = true]; */
+        if (message.Code !== "")
+            writer.tag(2, WireType.LengthDelimited).string(message.Code);
+        /* api.EntityType Entity = 3 [deprecated = true]; */
+        if (message.Entity !== 0)
+            writer.tag(3, WireType.Varint).int32(message.Entity);
+        /* string ID = 4; */
+        if (message.ID !== "")
+            writer.tag(4, WireType.LengthDelimited).string(message.ID);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message api.DeleteAttachmentTypeOnSiteRequest
+ */
+export const DeleteAttachmentTypeOnSiteRequest = new DeleteAttachmentTypeOnSiteRequest$Type();
+// @generated message type with reflection information, may provide speed optimized methods
 class DeleteAttachmentTypeResponse$Type extends MessageType<DeleteAttachmentTypeResponse> {
     constructor() {
         super("api.DeleteAttachmentTypeResponse", []);
@@ -873,6 +1404,52 @@ class DeleteAllAttachmentsTypeRequest$Type extends MessageType<DeleteAllAttachme
  */
 export const DeleteAllAttachmentsTypeRequest = new DeleteAllAttachmentsTypeRequest$Type();
 // @generated message type with reflection information, may provide speed optimized methods
+class DeleteAllAttachmentsTypeOnSiteRequest$Type extends MessageType<DeleteAllAttachmentsTypeOnSiteRequest> {
+    constructor() {
+        super("api.DeleteAllAttachmentsTypeOnSiteRequest", [
+            { no: 1, name: "Header", kind: "message", localName: "Header", jsonName: "Header", T: () => RequestSiteHeader, options: { "validate.rules": { message: { required: true } } } }
+        ], { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_schema": { jsonSchema: { required: ["Header"] } } });
+    }
+    create(value?: PartialMessage<DeleteAllAttachmentsTypeOnSiteRequest>): DeleteAllAttachmentsTypeOnSiteRequest {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        if (value !== undefined)
+            reflectionMergePartial<DeleteAllAttachmentsTypeOnSiteRequest>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: DeleteAllAttachmentsTypeOnSiteRequest): DeleteAllAttachmentsTypeOnSiteRequest {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* api.RequestSiteHeader Header */ 1:
+                    message.Header = RequestSiteHeader.internalBinaryRead(reader, reader.uint32(), options, message.Header);
+                    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: DeleteAllAttachmentsTypeOnSiteRequest, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* api.RequestSiteHeader Header = 1; */
+        if (message.Header)
+            RequestSiteHeader.internalBinaryWrite(message.Header, writer.tag(1, 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.DeleteAllAttachmentsTypeOnSiteRequest
+ */
+export const DeleteAllAttachmentsTypeOnSiteRequest = new DeleteAllAttachmentsTypeOnSiteRequest$Type();
+// @generated message type with reflection information, may provide speed optimized methods
 class DeleteAllAttachmentsTypeResponse$Type extends MessageType<DeleteAllAttachmentsTypeResponse> {
     constructor() {
         super("api.DeleteAllAttachmentsTypeResponse", []);
@@ -919,5 +1496,11 @@ export const AttachmentTypeService = new ServiceType("api.AttachmentTypeService"
     { name: "List", options: { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_operation": { tags: ["AttachmentType"], description: "List attachment types on a project" }, "api.rscType": "Project", "api.roles": "Platform.AttachmentType", "google.api.method_visibility": { restriction: "SDK" } }, I: ListAttachmentTypeRequest, O: ListAttachmentTypeResponse },
     { name: "Update", options: { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_operation": { tags: ["AttachmentType"], description: "Update an attachment type for an entity" }, "api.rscType": "Project", "api.roles": "", "google.api.method_visibility": { restriction: "SDK" } }, I: UpdateAttachmentTypeRequest, O: UpdateAttachmentTypeResponse },
     { name: "Delete", options: { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_operation": { tags: ["AttachmentType"], description: "Delete an attachment type for an entity" }, "api.rscType": "Project", "api.roles": "", "google.api.method_visibility": { restriction: "SDK" } }, I: DeleteAttachmentTypeRequest, O: DeleteAttachmentTypeResponse },
-    { name: "DeleteAll", options: { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_operation": { tags: ["AttachmentType"], description: "Delete all attachments type for entities within the project" }, "api.rscType": "Project", "api.roles": "Platform.Project-Deletion", "google.api.method_visibility": { restriction: "SDK" } }, I: DeleteAllAttachmentsTypeRequest, O: DeleteAllAttachmentsTypeResponse }
+    { name: "DeleteAll", options: { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_operation": { tags: ["AttachmentType"], description: "Delete all attachments type for entities within the project" }, "api.rscType": "Project", "api.roles": "Platform.Project-Deletion", "google.api.method_visibility": { restriction: "SDK" } }, I: DeleteAllAttachmentsTypeRequest, O: DeleteAllAttachmentsTypeResponse },
+    { name: "CreateOnSite", options: { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_operation": { tags: ["AttachmentType"], description: "Create an attachment type for an entity" }, "api.rscType": "Site", "api.roles": "", "google.api.method_visibility": { restriction: "SDK" } }, I: CreateAttachmentTypeOnSiteRequest, O: CreateAttachmentTypeResponse },
+    { name: "GetOnSite", options: { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_operation": { tags: ["AttachmentType"], description: "Get an attachment type for an entity" }, "api.rscType": "Site", "api.roles": "", "google.api.method_visibility": { restriction: "SDK" } }, I: GetAttachmentTypeOnSiteRequest, O: GetAttachmentTypeResponse },
+    { name: "ListOnSite", options: { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_operation": { tags: ["AttachmentType"], description: "List attachment types on a site" }, "api.rscType": "Site", "api.roles": "Platform.AttachmentType", "google.api.method_visibility": { restriction: "SDK" } }, I: ListAttachmentTypeOnSiteRequest, O: ListAttachmentTypeResponse },
+    { name: "UpdateOnSite", options: { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_operation": { tags: ["AttachmentType"], description: "Update an attachment type for an entity" }, "api.rscType": "Site", "api.roles": "", "google.api.method_visibility": { restriction: "SDK" } }, I: UpdateAttachmentTypeOnSiteRequest, O: UpdateAttachmentTypeResponse },
+    { name: "DeleteOnSite", options: { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_operation": { tags: ["AttachmentType"], description: "Delete an attachment type for an entity" }, "api.rscType": "Site", "api.roles": "", "google.api.method_visibility": { restriction: "SDK" } }, I: DeleteAttachmentTypeOnSiteRequest, O: DeleteAttachmentTypeResponse },
+    { name: "DeleteAllOnSite", options: { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_operation": { tags: ["AttachmentType"], description: "Delete all attachments type for entities within the site" }, "api.rscType": "Site", "api.roles": "Platform.Site-Deletion", "google.api.method_visibility": { restriction: "SDK" } }, I: DeleteAllAttachmentsTypeOnSiteRequest, O: DeleteAllAttachmentsTypeResponse }
 ], { "api.k8sService": "attachment-server" });

attachmentV2.client.ts

@@ -4,6 +4,9 @@
 import type { RpcTransport } from "@protobuf-ts/runtime-rpc";
 import type { ServiceInfo } from "@protobuf-ts/runtime-rpc";
 import { AttachmentServiceV2 } from "./attachmentV2";
+import type { DeleteAllAttachmentsOnSiteV2Request } from "./attachmentV2";
+import type { ListAttachmentsOnSiteV2Response } from "./attachmentV2";
+import type { ListAttachmentsOnSiteV2Request } from "./attachmentV2";
 import type { DeleteAllAttachmentsV2Response } from "./attachmentV2";
 import type { DeleteAllAttachmentsV2Request } from "./attachmentV2";
 import type { ShareAttachmentV2Response } from "./attachmentV2";
@@ -53,6 +56,14 @@ export interface IAttachmentServiceV2Client {
      * @generated from protobuf rpc: DeleteAll
      */
     deleteAll(input: DeleteAllAttachmentsV2Request, options?: RpcOptions): UnaryCall<DeleteAllAttachmentsV2Request, DeleteAllAttachmentsV2Response>;
+    /**
+     * @generated from protobuf rpc: ListOnSite
+     */
+    listOnSite(input: ListAttachmentsOnSiteV2Request, options?: RpcOptions): UnaryCall<ListAttachmentsOnSiteV2Request, ListAttachmentsOnSiteV2Response>;
+    /**
+     * @generated from protobuf rpc: DeleteAllSite
+     */
+    deleteAllSite(input: DeleteAllAttachmentsOnSiteV2Request, options?: RpcOptions): UnaryCall<DeleteAllAttachmentsOnSiteV2Request, DeleteAllAttachmentsV2Response>;
 }
 /**
  * @generated from protobuf service api.AttachmentServiceV2
@@ -112,4 +123,18 @@ export class AttachmentServiceV2Client implements IAttachmentServiceV2Client, Se
         const method = this.methods[6], opt = this._transport.mergeOptions(options);
         return stackIntercept<DeleteAllAttachmentsV2Request, DeleteAllAttachmentsV2Response>("unary", this._transport, method, opt, input);
     }
+    /**
+     * @generated from protobuf rpc: ListOnSite
+     */
+    listOnSite(input: ListAttachmentsOnSiteV2Request, options?: RpcOptions): UnaryCall<ListAttachmentsOnSiteV2Request, ListAttachmentsOnSiteV2Response> {
+        const method = this.methods[7], opt = this._transport.mergeOptions(options);
+        return stackIntercept<ListAttachmentsOnSiteV2Request, ListAttachmentsOnSiteV2Response>("unary", this._transport, method, opt, input);
+    }
+    /**
+     * @generated from protobuf rpc: DeleteAllSite
+     */
+    deleteAllSite(input: DeleteAllAttachmentsOnSiteV2Request, options?: RpcOptions): UnaryCall<DeleteAllAttachmentsOnSiteV2Request, DeleteAllAttachmentsV2Response> {
+        const method = this.methods[8], opt = this._transport.mergeOptions(options);
+        return stackIntercept<DeleteAllAttachmentsOnSiteV2Request, DeleteAllAttachmentsV2Response>("unary", this._transport, method, opt, input);
+    }
 }

attachmentV2.ts

@@ -11,6 +11,8 @@ import { UnknownFieldHandler } from "@protobuf-ts/runtime";
 import type { PartialMessage } from "@protobuf-ts/runtime";
 import { reflectionMergePartial } from "@protobuf-ts/runtime";
 import { MessageType } from "@protobuf-ts/runtime";
+import { ResponseSiteHeader } from "./shared";
+import { RequestSiteHeader } from "./shared";
 import { ResponseHeader } from "./shared";
 import { EntityType } from "./shared";
 import { RequestProjectHeader } from "./shared";
@@ -18,6 +20,7 @@ import { FileDataRequest } from "./shared";
 import { FileDataResponse } from "./shared";
 import { AttachmentTypeResponseHeader } from "./shared";
 import { RequestAttachmentTypeHeader } from "./shared";
+import { ResourceType } from "./shared";
 import { AttachmentType } from "./shared";
 // ========== MODEL MESSAGES ==========
 
@@ -26,10 +29,11 @@ import { AttachmentType } from "./shared";
  */
 export interface Attachment {
     /**
-     * @generated from protobuf field: string ProjectID = 1
+     * string ProjectID = 1
-     */
+     *     [
-    ProjectID: string;
+     *         (validate.rules).string.min_len = 1
-    /**
+     *     ];
+     *
      * @generated from protobuf field: string Name = 2
      */
     Name: string;
@@ -61,6 +65,14 @@ export interface Attachment {
      * @generated from protobuf field: string WebURI = 13
      */
     WebURI: string;
+    /**
+     * @generated from protobuf field: api.ResourceType ResourceType = 14
+     */
+    ResourceType: ResourceType;
+    /**
+     * @generated from protobuf field: string ResourceID = 15
+     */
+    ResourceID: string;
 }
 // ========== REQUESTS & RESPONSE MESSAGES ==========
 
@@ -234,6 +246,38 @@ export interface ListAttachmentsV2Response {
      */
     Attachments: Attachment[];
 }
+/**
+ * @generated from protobuf message api.ListAttachmentsOnSiteV2Request
+ */
+export interface ListAttachmentsOnSiteV2Request {
+    /**
+     * @generated from protobuf field: api.RequestSiteHeader Header = 1
+     */
+    Header?: RequestSiteHeader;
+    /**
+     * @generated from protobuf field: string EntityRefID = 3
+     */
+    EntityRefID: string;
+    /**
+     * @generated from protobuf field: api.EntityType EntityType = 4
+     */
+    EntityType: EntityType;
+}
+/**
+ * @generated from protobuf message api.ListAttachmentsOnSiteV2Response
+ */
+export interface ListAttachmentsOnSiteV2Response {
+    /**
+     * Header of the response
+     *
+     * @generated from protobuf field: api.ResponseSiteHeader Header = 2
+     */
+    Header?: ResponseSiteHeader;
+    /**
+     * @generated from protobuf field: repeated api.Attachment Attachments = 1
+     */
+    Attachments: Attachment[];
+}
 /**
  * Share
  *
@@ -277,6 +321,15 @@ export interface DeleteAllAttachmentsV2Request {
      */
     Header?: RequestProjectHeader;
 }
+/**
+ * @generated from protobuf message api.DeleteAllAttachmentsOnSiteV2Request
+ */
+export interface DeleteAllAttachmentsOnSiteV2Request {
+    /**
+     * @generated from protobuf field: api.RequestSiteHeader Header = 1
+     */
+    Header?: RequestSiteHeader;
+}
 /**
  * @generated from protobuf message api.DeleteAllAttachmentsV2Response
  */
@@ -303,7 +356,6 @@ export enum AttachmentKind {
 class Attachment$Type extends MessageType<Attachment> {
     constructor() {
         super("api.Attachment", [
-            { no: 1, name: "ProjectID", kind: "scalar", localName: "ProjectID", jsonName: "ProjectID", T: 9 /*ScalarType.STRING*/, options: { "validate.rules": { string: { minLen: "1" } } } },
             { no: 2, name: "Name", kind: "scalar", localName: "Name", jsonName: "Name", T: 9 /*ScalarType.STRING*/, options: { "validate.rules": { string: { minLen: "1" } } } },
             { no: 3, name: "EntityRefID", kind: "scalar", localName: "EntityRefID", jsonName: "EntityRefID", T: 9 /*ScalarType.STRING*/, options: { "validate.rules": { string: { minLen: "1" } } } },
             { no: 4, name: "AttachmentType", kind: "message", localName: "AttachmentType", jsonName: "AttachmentType", T: () => AttachmentType, options: { "validate.rules": { message: { required: true } } } },
@@ -311,12 +363,13 @@ class Attachment$Type extends MessageType<Attachment> {
             { no: 6, name: "MIMEType", kind: "scalar", localName: "MIMEType", jsonName: "MIMEType", T: 9 /*ScalarType.STRING*/, options: { "validate.rules": { string: { minLen: "1" } } } },
             { no: 11, name: "UploadedAt", kind: "scalar", localName: "UploadedAt", jsonName: "UploadedAt", T: 9 /*ScalarType.STRING*/, options: { "validate.rules": { string: { dateIso8601: true } }, "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field": { description: "UTC date/time in <a href='https://en.wikipedia.org/wiki/ISO_8601'>ISO 8601</a> format" } } },
             { no: 12, name: "Kind", kind: "enum", localName: "Kind", jsonName: "Kind", T: () => ["api.AttachmentKind", AttachmentKind], options: { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field": { description: "Kind of the attachment (file or link)" } } },
-            { no: 13, name: "WebURI", kind: "scalar", localName: "WebURI", jsonName: "WebURI", T: 9 /*ScalarType.STRING*/, options: { "validate.rules": { string: { minLen: "1" } }, "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field": { description: "URI of the attachment through which it can be accessed on an authenticated web app. In case the Attachment is a link, the URI is empty." } } }
+            { no: 13, name: "WebURI", kind: "scalar", localName: "WebURI", jsonName: "WebURI", T: 9 /*ScalarType.STRING*/, options: { "validate.rules": { string: { minLen: "1" } }, "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field": { description: "URI of the attachment through which it can be accessed on an authenticated web app. In case the Attachment is a link, the URI is empty." } } },
+            { no: 14, name: "ResourceType", kind: "enum", localName: "ResourceType", jsonName: "ResourceType", T: () => ["api.ResourceType", ResourceType], options: { "validate.rules": { enum: { definedOnly: true } } } },
+            { no: 15, name: "ResourceID", kind: "scalar", localName: "ResourceID", jsonName: "ResourceID", T: 9 /*ScalarType.STRING*/, options: { "validate.rules": { string: { minLen: "1" } } } }
         ]);
     }
     create(value?: PartialMessage<Attachment>): Attachment {
         const message = globalThis.Object.create((this.messagePrototype!));
-        message.ProjectID = "";
         message.Name = "";
         message.EntityRefID = "";
         message.URI = "";
@@ -324,6 +377,8 @@ class Attachment$Type extends MessageType<Attachment> {
         message.UploadedAt = "";
         message.Kind = 0;
         message.WebURI = "";
+        message.ResourceType = 0;
+        message.ResourceID = "";
         if (value !== undefined)
             reflectionMergePartial<Attachment>(this, message, value);
         return message;
@@ -333,9 +388,6 @@ class Attachment$Type extends MessageType<Attachment> {
         while (reader.pos < end) {
             let [fieldNo, wireType] = reader.tag();
             switch (fieldNo) {
-                case /* string ProjectID */ 1:
-                    message.ProjectID = reader.string();
-                    break;
                 case /* string Name */ 2:
                     message.Name = reader.string();
                     break;
@@ -360,6 +412,12 @@ class Attachment$Type extends MessageType<Attachment> {
                 case /* string WebURI */ 13:
                     message.WebURI = reader.string();
                     break;
+                case /* api.ResourceType ResourceType */ 14:
+                    message.ResourceType = reader.int32();
+                    break;
+                case /* string ResourceID */ 15:
+                    message.ResourceID = reader.string();
+                    break;
                 default:
                     let u = options.readUnknownField;
                     if (u === "throw")
@@ -372,9 +430,6 @@ class Attachment$Type extends MessageType<Attachment> {
         return message;
     }
     internalBinaryWrite(message: Attachment, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
-        /* string ProjectID = 1; */
-        if (message.ProjectID !== "")
-            writer.tag(1, WireType.LengthDelimited).string(message.ProjectID);
         /* string Name = 2; */
         if (message.Name !== "")
             writer.tag(2, WireType.LengthDelimited).string(message.Name);
@@ -399,6 +454,12 @@ class Attachment$Type extends MessageType<Attachment> {
         /* string WebURI = 13; */
         if (message.WebURI !== "")
             writer.tag(13, WireType.LengthDelimited).string(message.WebURI);
+        /* api.ResourceType ResourceType = 14; */
+        if (message.ResourceType !== 0)
+            writer.tag(14, WireType.Varint).int32(message.ResourceType);
+        /* string ResourceID = 15; */
+        if (message.ResourceID !== "")
+            writer.tag(15, WireType.LengthDelimited).string(message.ResourceID);
         let u = options.writeUnknownFields;
         if (u !== false)
             (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
@@ -986,6 +1047,122 @@ class ListAttachmentsV2Response$Type extends MessageType<ListAttachmentsV2Respon
  */
 export const ListAttachmentsV2Response = new ListAttachmentsV2Response$Type();
 // @generated message type with reflection information, may provide speed optimized methods
+class ListAttachmentsOnSiteV2Request$Type extends MessageType<ListAttachmentsOnSiteV2Request> {
+    constructor() {
+        super("api.ListAttachmentsOnSiteV2Request", [
+            { no: 1, name: "Header", kind: "message", localName: "Header", jsonName: "Header", T: () => RequestSiteHeader, options: { "validate.rules": { message: { required: true } } } },
+            { no: 3, name: "EntityRefID", kind: "scalar", localName: "EntityRefID", jsonName: "EntityRefID", T: 9 /*ScalarType.STRING*/, options: { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field": { description: "Optional : Identifier of the entity where the attachment is located" } } },
+            { no: 4, name: "EntityType", kind: "enum", localName: "EntityType", jsonName: "EntityType", T: () => ["api.EntityType", EntityType], options: { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field": { description: "Optional : Type of the entity where the attachment is located" } } }
+        ], { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_schema": { jsonSchema: { required: ["Header"] } } });
+    }
+    create(value?: PartialMessage<ListAttachmentsOnSiteV2Request>): ListAttachmentsOnSiteV2Request {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.EntityRefID = "";
+        message.EntityType = 0;
+        if (value !== undefined)
+            reflectionMergePartial<ListAttachmentsOnSiteV2Request>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: ListAttachmentsOnSiteV2Request): ListAttachmentsOnSiteV2Request {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* api.RequestSiteHeader Header */ 1:
+                    message.Header = RequestSiteHeader.internalBinaryRead(reader, reader.uint32(), options, message.Header);
+                    break;
+                case /* string EntityRefID */ 3:
+                    message.EntityRefID = reader.string();
+                    break;
+                case /* api.EntityType EntityType */ 4:
+                    message.EntityType = reader.int32();
+                    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: ListAttachmentsOnSiteV2Request, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* api.RequestSiteHeader Header = 1; */
+        if (message.Header)
+            RequestSiteHeader.internalBinaryWrite(message.Header, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+        /* string EntityRefID = 3; */
+        if (message.EntityRefID !== "")
+            writer.tag(3, WireType.LengthDelimited).string(message.EntityRefID);
+        /* api.EntityType EntityType = 4; */
+        if (message.EntityType !== 0)
+            writer.tag(4, WireType.Varint).int32(message.EntityType);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message api.ListAttachmentsOnSiteV2Request
+ */
+export const ListAttachmentsOnSiteV2Request = new ListAttachmentsOnSiteV2Request$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class ListAttachmentsOnSiteV2Response$Type extends MessageType<ListAttachmentsOnSiteV2Response> {
+    constructor() {
+        super("api.ListAttachmentsOnSiteV2Response", [
+            { no: 2, name: "Header", kind: "message", localName: "Header", jsonName: "Header", T: () => ResponseSiteHeader, options: { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field": { description: "Header of the response" } } },
+            { no: 1, name: "Attachments", kind: "message", localName: "Attachments", jsonName: "Attachments", repeat: 2 /*RepeatType.UNPACKED*/, T: () => Attachment, options: { "validate.rules": { repeated: { minItems: "1" } }, "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field": { description: "List of attachments matching to the request" } } }
+        ]);
+    }
+    create(value?: PartialMessage<ListAttachmentsOnSiteV2Response>): ListAttachmentsOnSiteV2Response {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.Attachments = [];
+        if (value !== undefined)
+            reflectionMergePartial<ListAttachmentsOnSiteV2Response>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: ListAttachmentsOnSiteV2Response): ListAttachmentsOnSiteV2Response {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* api.ResponseSiteHeader Header */ 2:
+                    message.Header = ResponseSiteHeader.internalBinaryRead(reader, reader.uint32(), options, message.Header);
+                    break;
+                case /* repeated api.Attachment Attachments */ 1:
+                    message.Attachments.push(Attachment.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: ListAttachmentsOnSiteV2Response, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* repeated api.Attachment Attachments = 1; */
+        for (let i = 0; i < message.Attachments.length; i++)
+            Attachment.internalBinaryWrite(message.Attachments[i], writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+        /* api.ResponseSiteHeader Header = 2; */
+        if (message.Header)
+            ResponseSiteHeader.internalBinaryWrite(message.Header, 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.ListAttachmentsOnSiteV2Response
+ */
+export const ListAttachmentsOnSiteV2Response = new ListAttachmentsOnSiteV2Response$Type();
+// @generated message type with reflection information, may provide speed optimized methods
 class ShareAttachmentV2Request$Type extends MessageType<ShareAttachmentV2Request> {
     constructor() {
         super("api.ShareAttachmentV2Request", [
@@ -1148,6 +1325,52 @@ class DeleteAllAttachmentsV2Request$Type extends MessageType<DeleteAllAttachment
  */
 export const DeleteAllAttachmentsV2Request = new DeleteAllAttachmentsV2Request$Type();
 // @generated message type with reflection information, may provide speed optimized methods
+class DeleteAllAttachmentsOnSiteV2Request$Type extends MessageType<DeleteAllAttachmentsOnSiteV2Request> {
+    constructor() {
+        super("api.DeleteAllAttachmentsOnSiteV2Request", [
+            { no: 1, name: "Header", kind: "message", localName: "Header", jsonName: "Header", T: () => RequestSiteHeader, options: { "validate.rules": { message: { required: true } } } }
+        ], { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_schema": { jsonSchema: { required: ["Header"] } } });
+    }
+    create(value?: PartialMessage<DeleteAllAttachmentsOnSiteV2Request>): DeleteAllAttachmentsOnSiteV2Request {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        if (value !== undefined)
+            reflectionMergePartial<DeleteAllAttachmentsOnSiteV2Request>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: DeleteAllAttachmentsOnSiteV2Request): DeleteAllAttachmentsOnSiteV2Request {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* api.RequestSiteHeader Header */ 1:
+                    message.Header = RequestSiteHeader.internalBinaryRead(reader, reader.uint32(), options, message.Header);
+                    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: DeleteAllAttachmentsOnSiteV2Request, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* api.RequestSiteHeader Header = 1; */
+        if (message.Header)
+            RequestSiteHeader.internalBinaryWrite(message.Header, writer.tag(1, 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.DeleteAllAttachmentsOnSiteV2Request
+ */
+export const DeleteAllAttachmentsOnSiteV2Request = new DeleteAllAttachmentsOnSiteV2Request$Type();
+// @generated message type with reflection information, may provide speed optimized methods
 class DeleteAllAttachmentsV2Response$Type extends MessageType<DeleteAllAttachmentsV2Response> {
     constructor() {
         super("api.DeleteAllAttachmentsV2Response", []);
@@ -1195,5 +1418,7 @@ export const AttachmentServiceV2 = new ServiceType("api.AttachmentServiceV2", [
     { name: "Delete", options: { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_operation": { tags: ["Attachment"], description: "Delete a document attached to an entity" }, "api.rscType": "AttachmentType", "api.roles": "AttachmentType.Writer", "google.api.method_visibility": { restriction: "SDK" } }, I: DeleteAttachmentV2Request, O: DeleteAttachmentV2Response },
     { name: "List", options: { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_operation": { tags: ["Attachment"], description: "List all documents attached to an entity" }, "api.rscType": "Project", "api.roles": "", "google.api.method_visibility": { restriction: "SDK" } }, I: ListAttachmentsV2Request, O: ListAttachmentsV2Response },
     { name: "Share", options: { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_operation": { tags: ["Attachment"], description: "Share a document attached to an entity" }, "api.rscType": "AttachmentType", "api.roles": "AttachmentType.Writer", "google.api.method_visibility": { restriction: "SDK" } }, I: ShareAttachmentV2Request, O: ShareAttachmentV2Response },
-    { name: "DeleteAll", options: { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_operation": { tags: ["Attachment"], description: "Delete all documents attached to entities within the project" }, "api.rscType": "Project", "api.roles": "Platform.Project-Deletion", "google.api.method_visibility": { restriction: "SDK" } }, I: DeleteAllAttachmentsV2Request, O: DeleteAllAttachmentsV2Response }
+    { name: "DeleteAll", options: { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_operation": { tags: ["Attachment"], description: "Delete all documents attached to entities within the project" }, "api.rscType": "Project", "api.roles": "Platform.Project-Deletion", "google.api.method_visibility": { restriction: "SDK" } }, I: DeleteAllAttachmentsV2Request, O: DeleteAllAttachmentsV2Response },
+    { name: "ListOnSite", options: { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_operation": { tags: ["Attachment"], description: "List all documents attached to an entity" }, "api.rscType": "Site", "api.roles": "", "google.api.method_visibility": { restriction: "SDK" } }, I: ListAttachmentsOnSiteV2Request, O: ListAttachmentsOnSiteV2Response },
+    { name: "DeleteAllSite", options: { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_operation": { tags: ["Attachment"], description: "Delete all documents attached to entities within the site" }, "api.rscType": "Site", "api.roles": "Platform.Site-Deletion", "google.api.method_visibility": { restriction: "SDK" } }, I: DeleteAllAttachmentsOnSiteV2Request, O: DeleteAllAttachmentsV2Response }
 ], { "api.k8sService": "attachment-server" });

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reflex-platform/npm-core-sdk",
-  "version": "1.11.0-SNAPSHOT-250729114314",
+  "version": "1.11.0-SNAPSHOT-250730071244",
   "description": "npm libs from core model proto files",
   "homepage": "",
   "main": "index.ts",

shared.ts

@@ -1537,10 +1537,11 @@ export interface AttachmentType {
      */
     ID: string;
     /**
-     * @generated from protobuf field: string ProjectID = 2
+     * string ProjectID = 2
-     */
+     *     [
-    ProjectID: string;
+     *         (validate.rules).string.min_len = 1
-    /**
+     *     ];
+     *
      * @generated from protobuf field: string Code = 3
      */
     Code: string;
@@ -1556,6 +1557,14 @@ export interface AttachmentType {
      * @generated from protobuf field: api.SharePolicy SharePolicy = 6
      */
     SharePolicy: SharePolicy;
+    /**
+     * @generated from protobuf field: api.ResourceType ResourceType = 8
+     */
+    ResourceType: ResourceType;
+    /**
+     * @generated from protobuf field: string ResourceID = 7
+     */
+    ResourceID: string;
 }
 /**
  * @generated from protobuf message api.AttachmentSummary
@@ -6820,21 +6829,23 @@ class AttachmentType$Type extends MessageType<AttachmentType> {
     constructor() {
         super("api.AttachmentType", [
             { no: 1, name: "ID", kind: "scalar", localName: "ID", jsonName: "ID", T: 9 /*ScalarType.STRING*/, options: { "validate.rules": { string: { minLen: "1" } } } },
-            { no: 2, name: "ProjectID", kind: "scalar", localName: "ProjectID", jsonName: "ProjectID", T: 9 /*ScalarType.STRING*/, options: { "validate.rules": { string: { minLen: "1" } } } },
             { no: 3, name: "Code", kind: "scalar", localName: "Code", jsonName: "Code", T: 9 /*ScalarType.STRING*/, options: { "validate.rules": { string: { minLen: "1" } } } },
             { no: 4, name: "Entity", kind: "enum", localName: "Entity", jsonName: "Entity", T: () => ["api.EntityType", EntityType], options: { "validate.rules": { enum: { definedOnly: true } } } },
             { no: 5, name: "Label", kind: "scalar", localName: "Label", jsonName: "Label", T: 9 /*ScalarType.STRING*/, options: { "validate.rules": { string: { minLen: "1" } } } },
-            { no: 6, name: "SharePolicy", kind: "enum", localName: "SharePolicy", jsonName: "SharePolicy", T: () => ["api.SharePolicy", SharePolicy], options: { "validate.rules": { enum: { definedOnly: true } } } }
+            { no: 6, name: "SharePolicy", kind: "enum", localName: "SharePolicy", jsonName: "SharePolicy", T: () => ["api.SharePolicy", SharePolicy], options: { "validate.rules": { enum: { definedOnly: true } } } },
+            { no: 8, name: "ResourceType", kind: "enum", localName: "ResourceType", jsonName: "ResourceType", T: () => ["api.ResourceType", ResourceType], options: { "validate.rules": { enum: { definedOnly: true } } } },
+            { no: 7, name: "ResourceID", kind: "scalar", localName: "ResourceID", jsonName: "ResourceID", T: 9 /*ScalarType.STRING*/, options: { "validate.rules": { string: { minLen: "1" } } } }
         ]);
     }
     create(value?: PartialMessage<AttachmentType>): AttachmentType {
         const message = globalThis.Object.create((this.messagePrototype!));
         message.ID = "";
-        message.ProjectID = "";
         message.Code = "";
         message.Entity = 0;
         message.Label = "";
         message.SharePolicy = 0;
+        message.ResourceType = 0;
+        message.ResourceID = "";
         if (value !== undefined)
             reflectionMergePartial<AttachmentType>(this, message, value);
         return message;
@@ -6847,9 +6858,6 @@ class AttachmentType$Type extends MessageType<AttachmentType> {
                 case /* string ID */ 1:
                     message.ID = reader.string();
                     break;
-                case /* string ProjectID */ 2:
-                    message.ProjectID = reader.string();
-                    break;
                 case /* string Code */ 3:
                     message.Code = reader.string();
                     break;
@@ -6862,6 +6870,12 @@ class AttachmentType$Type extends MessageType<AttachmentType> {
                 case /* api.SharePolicy SharePolicy */ 6:
                     message.SharePolicy = reader.int32();
                     break;
+                case /* api.ResourceType ResourceType */ 8:
+                    message.ResourceType = reader.int32();
+                    break;
+                case /* string ResourceID */ 7:
+                    message.ResourceID = reader.string();
+                    break;
                 default:
                     let u = options.readUnknownField;
                     if (u === "throw")
@@ -6877,9 +6891,6 @@ class AttachmentType$Type extends MessageType<AttachmentType> {
         /* string ID = 1; */
         if (message.ID !== "")
             writer.tag(1, WireType.LengthDelimited).string(message.ID);
-        /* string ProjectID = 2; */
-        if (message.ProjectID !== "")
-            writer.tag(2, WireType.LengthDelimited).string(message.ProjectID);
         /* string Code = 3; */
         if (message.Code !== "")
             writer.tag(3, WireType.LengthDelimited).string(message.Code);
@@ -6892,6 +6903,12 @@ class AttachmentType$Type extends MessageType<AttachmentType> {
         /* api.SharePolicy SharePolicy = 6; */
         if (message.SharePolicy !== 0)
             writer.tag(6, WireType.Varint).int32(message.SharePolicy);
+        /* string ResourceID = 7; */
+        if (message.ResourceID !== "")
+            writer.tag(7, WireType.LengthDelimited).string(message.ResourceID);
+        /* api.ResourceType ResourceType = 8; */
+        if (message.ResourceType !== 0)
+            writer.tag(8, WireType.Varint).int32(message.ResourceType);
         let u = options.writeUnknownFields;
         if (u !== false)
             (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);