@trash-streamers/contracts 1.1.63 → 1.1.64

package/dist/gen/ts/google/protobuf/field_mask.d.ts

@@ -0,0 +1,213 @@
+export declare const protobufPackage = "google.protobuf";
+/**
+ * `FieldMask` represents a set of symbolic field paths, for example:
+ *
+ *     paths: "f.a"
+ *     paths: "f.b.d"
+ *
+ * Here `f` represents a field in some root message, `a` and `b`
+ * fields in the message found in `f`, and `d` a field found in the
+ * message in `f.b`.
+ *
+ * Field masks are used to specify a subset of fields that should be
+ * returned by a get operation or modified by an update operation.
+ * Field masks also have a custom JSON encoding (see below).
+ *
+ * # Field Masks in Projections
+ *
+ * When used in the context of a projection, a response message or
+ * sub-message is filtered by the API to only contain those fields as
+ * specified in the mask. For example, if the mask in the previous
+ * example is applied to a response message as follows:
+ *
+ *     f {
+ *       a : 22
+ *       b {
+ *         d : 1
+ *         x : 2
+ *       }
+ *       y : 13
+ *     }
+ *     z: 8
+ *
+ * The result will not contain specific values for fields x,y and z
+ * (their value will be set to the default, and omitted in proto text
+ * output):
+ *
+ *     f {
+ *       a : 22
+ *       b {
+ *         d : 1
+ *       }
+ *     }
+ *
+ * A repeated field is not allowed except at the last position of a
+ * paths string.
+ *
+ * If a FieldMask object is not present in a get operation, the
+ * operation applies to all fields (as if a FieldMask of all fields
+ * had been specified).
+ *
+ * Note that a field mask does not necessarily apply to the
+ * top-level response message. In case of a REST get operation, the
+ * field mask applies directly to the response, but in case of a REST
+ * list operation, the mask instead applies to each individual message
+ * in the returned resource list. In case of a REST custom method,
+ * other definitions may be used. Where the mask applies will be
+ * clearly documented together with its declaration in the API.  In
+ * any case, the effect on the returned resource/resources is required
+ * behavior for APIs.
+ *
+ * # Field Masks in Update Operations
+ *
+ * A field mask in update operations specifies which fields of the
+ * targeted resource are going to be updated. The API is required
+ * to only change the values of the fields as specified in the mask
+ * and leave the others untouched. If a resource is passed in to
+ * describe the updated values, the API ignores the values of all
+ * fields not covered by the mask.
+ *
+ * If a repeated field is specified for an update operation, new values will
+ * be appended to the existing repeated field in the target resource. Note that
+ * a repeated field is only allowed in the last position of a `paths` string.
+ *
+ * If a sub-message is specified in the last position of the field mask for an
+ * update operation, then new value will be merged into the existing sub-message
+ * in the target resource.
+ *
+ * For example, given the target message:
+ *
+ *     f {
+ *       b {
+ *         d: 1
+ *         x: 2
+ *       }
+ *       c: [1]
+ *     }
+ *
+ * And an update message:
+ *
+ *     f {
+ *       b {
+ *         d: 10
+ *       }
+ *       c: [2]
+ *     }
+ *
+ * then if the field mask is:
+ *
+ *  paths: ["f.b", "f.c"]
+ *
+ * then the result will be:
+ *
+ *     f {
+ *       b {
+ *         d: 10
+ *         x: 2
+ *       }
+ *       c: [1, 2]
+ *     }
+ *
+ * An implementation may provide options to override this default behavior for
+ * repeated and message fields.
+ *
+ * In order to reset a field's value to the default, the field must
+ * be in the mask and set to the default value in the provided resource.
+ * Hence, in order to reset all fields of a resource, provide a default
+ * instance of the resource and set all fields in the mask, or do
+ * not provide a mask as described below.
+ *
+ * If a field mask is not present on update, the operation applies to
+ * all fields (as if a field mask of all fields has been specified).
+ * Note that in the presence of schema evolution, this may mean that
+ * fields the client does not know and has therefore not filled into
+ * the request will be reset to their default. If this is unwanted
+ * behavior, a specific service may require a client to always specify
+ * a field mask, producing an error if not.
+ *
+ * As with get operations, the location of the resource which
+ * describes the updated values in the request message depends on the
+ * operation kind. In any case, the effect of the field mask is
+ * required to be honored by the API.
+ *
+ * ## Considerations for HTTP REST
+ *
+ * The HTTP kind of an update operation which uses a field mask must
+ * be set to PATCH instead of PUT in order to satisfy HTTP semantics
+ * (PUT must only be used for full updates).
+ *
+ * # JSON Encoding of Field Masks
+ *
+ * In JSON, a field mask is encoded as a single string where paths are
+ * separated by a comma. Fields name in each path are converted
+ * to/from lower-camel naming conventions.
+ *
+ * As an example, consider the following message declarations:
+ *
+ *     message Profile {
+ *       User user = 1;
+ *       Photo photo = 2;
+ *     }
+ *     message User {
+ *       string display_name = 1;
+ *       string address = 2;
+ *     }
+ *
+ * In proto a field mask for `Profile` may look as such:
+ *
+ *     mask {
+ *       paths: "user.display_name"
+ *       paths: "photo"
+ *     }
+ *
+ * In JSON, the same mask is represented as below:
+ *
+ *     {
+ *       mask: "user.displayName,photo"
+ *     }
+ *
+ * # Field Masks and Oneof Fields
+ *
+ * Field masks treat fields in oneofs just as regular fields. Consider the
+ * following message:
+ *
+ *     message SampleMessage {
+ *       oneof test_oneof {
+ *         string name = 4;
+ *         SubMessage sub_message = 9;
+ *       }
+ *     }
+ *
+ * The field mask can be:
+ *
+ *     mask {
+ *       paths: "name"
+ *     }
+ *
+ * Or:
+ *
+ *     mask {
+ *       paths: "sub_message"
+ *     }
+ *
+ * Note that oneof type names ("test_oneof" in this case) cannot be used in
+ * paths.
+ *
+ * ## Field Mask Verification
+ *
+ * The implementation of any API method which has a FieldMask type field in the
+ * request should verify the included field paths, and return an
+ * `INVALID_ARGUMENT` error if any path is unmappable.
+ */
+export interface FieldMask {
+    /** The set of field mask paths. */
+    paths: string[];
+}
+export declare const GOOGLE_PROTOBUF_PACKAGE_NAME = "google.protobuf";
+export declare const FieldMask: MessageFns<FieldMask> & FieldMaskWrapperFns;
+export interface MessageFns<T> {
+}
+export interface FieldMaskWrapperFns {
+    wrap(paths: string[]): FieldMask;
+    unwrap(message: FieldMask): string[];
+}

package/dist/gen/ts/google/protobuf/field_mask.js

@@ -0,0 +1,24 @@
+"use strict";
+// Code generated by protoc-gen-ts_proto. DO NOT EDIT.
+// versions:
+//   protoc-gen-ts_proto  v2.10.1
+//   protoc               v6.33.5
+// source: google/protobuf/field_mask.proto
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FieldMask = exports.GOOGLE_PROTOBUF_PACKAGE_NAME = exports.protobufPackage = void 0;
+/* eslint-disable */
+exports.protobufPackage = "google.protobuf";
+exports.GOOGLE_PROTOBUF_PACKAGE_NAME = "google.protobuf";
+function createBaseFieldMask() {
+    return { paths: [] };
+}
+exports.FieldMask = {
+    wrap(paths) {
+        const result = createBaseFieldMask();
+        result.paths = paths;
+        return result;
+    },
+    unwrap(message) {
+        return message.paths;
+    },
+};

package/dist/gen/ts/video.d.ts

@@ -41,6 +41,15 @@ export interface SettingVideoBySlugRequest {
 export interface SettingVideoBySlugResponce {
     video: Video | undefined;
 }
+export interface UpdateSettingsVideoRequst {
+    slug: string;
+    ownerId: string;
+    video: Video | undefined;
+    updateMask: string[] | undefined;
+}
+export interface UpdateSettingsVideoResponse {
+    video: Video | undefined;
+}
 export interface Video {
     id: string;
     ownerId: string;
@@ -61,12 +70,14 @@ export interface VideoServiceClient {
     getAllVideosOwner(request: GetAllVideosOwnerRequest): Observable<GetAllVideosOwnerResponse>;
     publicVideoBySlug(request: PublicVideoBySlugRequest): Observable<PublicVideoBySlugResponce>;
     settingVideoBySlug(request: SettingVideoBySlugRequest): Observable<SettingVideoBySlugResponce>;
+    updateSettingsVideo(request: UpdateSettingsVideoRequst): Observable<UpdateSettingsVideoResponse>;
 }
 export interface VideoServiceController {
     confirmVideoUpload(request: ConfirmVideoUploadRequest): Promise<ConfirmVideoUploadResponse> | Observable<ConfirmVideoUploadResponse> | ConfirmVideoUploadResponse;
     getAllVideosOwner(request: GetAllVideosOwnerRequest): Promise<GetAllVideosOwnerResponse> | Observable<GetAllVideosOwnerResponse> | GetAllVideosOwnerResponse;
     publicVideoBySlug(request: PublicVideoBySlugRequest): Promise<PublicVideoBySlugResponce> | Observable<PublicVideoBySlugResponce> | PublicVideoBySlugResponce;
     settingVideoBySlug(request: SettingVideoBySlugRequest): Promise<SettingVideoBySlugResponce> | Observable<SettingVideoBySlugResponce> | SettingVideoBySlugResponce;
+    updateSettingsVideo(request: UpdateSettingsVideoRequst): Promise<UpdateSettingsVideoResponse> | Observable<UpdateSettingsVideoResponse> | UpdateSettingsVideoResponse;
 }
 export declare function VideoServiceControllerMethods(): (constructor: Function) => void;
 export declare const VIDEO_SERVICE_NAME = "VideoService";

package/dist/gen/ts/video.js

@@ -42,6 +42,7 @@ function VideoServiceControllerMethods() {
             "getAllVideosOwner",
             "publicVideoBySlug",
             "settingVideoBySlug",
+            "updateSettingsVideo",
         ];
         for (const method of grpcMethods) {
             const descriptor = Reflect.getOwnPropertyDescriptor(constructor.prototype, method);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@trash-streamers/contracts",
-  "version": "1.1.63",
+  "version": "1.1.64",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "scripts": {

package/proto/video.proto

@@ -3,12 +3,14 @@ syntax = "proto3";
 package video.v1;
 
 import "google/protobuf/timestamp.proto";
+import "google/protobuf/field_mask.proto";
 service VideoService {
     rpc ConfirmVideoUpload (ConfirmVideoUploadRequest) returns (ConfirmVideoUploadResponse);
     
     rpc GetAllVideosOwner (GetAllVideosOwnerRequest) returns (GetAllVideosOwnerResponse);
     rpc PublicVideoBySlug (PublicVideoBySlugRequest) returns (PublicVideoBySlugResponce);
     rpc SettingVideoBySlug (SettingVideoBySlugRequest) returns (SettingVideoBySlugResponce);
+    rpc UpdateSettingsVideo (UpdateSettingsVideoRequst) returns (UpdateSettingsVideoResponse);
 }
 
 message ConfirmVideoUploadRequest {
@@ -46,6 +48,17 @@ message SettingVideoBySlugRequest {
 message  SettingVideoBySlugResponce{
   Video video =1;
 }
+
+message UpdateSettingsVideoRequst {
+  string slug = 1;
+  string owner_id = 2;
+  Video video = 3;
+  google.protobuf.FieldMask update_mask = 4;
+}
+
+message UpdateSettingsVideoResponse {
+  Video video = 1;
+}
 message Video {
 	string id = 1;
 	string owner_id = 2;