@fraym/proto 0.4.1 → 0.5.1

package/freym/migrations/management/service.d.ts

@@ -0,0 +1,84 @@
+/// <reference types="node" />
+import { CallOptions, ChannelCredentials, Client, ClientDuplexStream, ClientOptions, ClientUnaryCall, handleBidiStreamingCall, handleUnaryCall, Metadata, ServiceError, UntypedServiceImplementation } from "@grpc/grpc-js";
+import { FinishRequest, FinishResponse } from "./finish";
+import { RegisterRequest, RegisterResponse } from "./register";
+import { RollbackRequest, RollbackResponse } from "./rollback";
+import { StartRequest, StartResponse } from "./start";
+import { StatusRequest, StatusResponse } from "./status";
+export declare const protobufPackage = "freym.migrations.management";
+export type ServiceService = typeof ServiceService;
+export declare const ServiceService: {
+    readonly register: {
+        readonly path: "/freym.migrations.management.Service/Register";
+        readonly requestStream: false;
+        readonly responseStream: false;
+        readonly requestSerialize: (value: RegisterRequest) => Buffer;
+        readonly requestDeserialize: (value: Buffer) => RegisterRequest;
+        readonly responseSerialize: (value: RegisterResponse) => Buffer;
+        readonly responseDeserialize: (value: Buffer) => RegisterResponse;
+    };
+    readonly status: {
+        readonly path: "/freym.migrations.management.Service/Status";
+        readonly requestStream: false;
+        readonly responseStream: false;
+        readonly requestSerialize: (value: StatusRequest) => Buffer;
+        readonly requestDeserialize: (value: Buffer) => StatusRequest;
+        readonly responseSerialize: (value: StatusResponse) => Buffer;
+        readonly responseDeserialize: (value: Buffer) => StatusResponse;
+    };
+    readonly start: {
+        readonly path: "/freym.migrations.management.Service/Start";
+        readonly requestStream: true;
+        readonly responseStream: true;
+        readonly requestSerialize: (value: StartRequest) => Buffer;
+        readonly requestDeserialize: (value: Buffer) => StartRequest;
+        readonly responseSerialize: (value: StartResponse) => Buffer;
+        readonly responseDeserialize: (value: Buffer) => StartResponse;
+    };
+    readonly finish: {
+        readonly path: "/freym.migrations.management.Service/Finish";
+        readonly requestStream: false;
+        readonly responseStream: false;
+        readonly requestSerialize: (value: FinishRequest) => Buffer;
+        readonly requestDeserialize: (value: Buffer) => FinishRequest;
+        readonly responseSerialize: (value: FinishResponse) => Buffer;
+        readonly responseDeserialize: (value: Buffer) => FinishResponse;
+    };
+    readonly rollback: {
+        readonly path: "/freym.migrations.management.Service/Rollback";
+        readonly requestStream: false;
+        readonly responseStream: false;
+        readonly requestSerialize: (value: RollbackRequest) => Buffer;
+        readonly requestDeserialize: (value: Buffer) => RollbackRequest;
+        readonly responseSerialize: (value: RollbackResponse) => Buffer;
+        readonly responseDeserialize: (value: Buffer) => RollbackResponse;
+    };
+};
+export interface ServiceServer extends UntypedServiceImplementation {
+    register: handleUnaryCall<RegisterRequest, RegisterResponse>;
+    status: handleUnaryCall<StatusRequest, StatusResponse>;
+    start: handleBidiStreamingCall<StartRequest, StartResponse>;
+    finish: handleUnaryCall<FinishRequest, FinishResponse>;
+    rollback: handleUnaryCall<RollbackRequest, RollbackResponse>;
+}
+export interface ServiceClient extends Client {
+    register(request: RegisterRequest, callback: (error: ServiceError | null, response: RegisterResponse) => void): ClientUnaryCall;
+    register(request: RegisterRequest, metadata: Metadata, callback: (error: ServiceError | null, response: RegisterResponse) => void): ClientUnaryCall;
+    register(request: RegisterRequest, metadata: Metadata, options: Partial<CallOptions>, callback: (error: ServiceError | null, response: RegisterResponse) => void): ClientUnaryCall;
+    status(request: StatusRequest, callback: (error: ServiceError | null, response: StatusResponse) => void): ClientUnaryCall;
+    status(request: StatusRequest, metadata: Metadata, callback: (error: ServiceError | null, response: StatusResponse) => void): ClientUnaryCall;
+    status(request: StatusRequest, metadata: Metadata, options: Partial<CallOptions>, callback: (error: ServiceError | null, response: StatusResponse) => void): ClientUnaryCall;
+    start(): ClientDuplexStream<StartRequest, StartResponse>;
+    start(options: Partial<CallOptions>): ClientDuplexStream<StartRequest, StartResponse>;
+    start(metadata: Metadata, options?: Partial<CallOptions>): ClientDuplexStream<StartRequest, StartResponse>;
+    finish(request: FinishRequest, callback: (error: ServiceError | null, response: FinishResponse) => void): ClientUnaryCall;
+    finish(request: FinishRequest, metadata: Metadata, callback: (error: ServiceError | null, response: FinishResponse) => void): ClientUnaryCall;
+    finish(request: FinishRequest, metadata: Metadata, options: Partial<CallOptions>, callback: (error: ServiceError | null, response: FinishResponse) => void): ClientUnaryCall;
+    rollback(request: RollbackRequest, callback: (error: ServiceError | null, response: RollbackResponse) => void): ClientUnaryCall;
+    rollback(request: RollbackRequest, metadata: Metadata, callback: (error: ServiceError | null, response: RollbackResponse) => void): ClientUnaryCall;
+    rollback(request: RollbackRequest, metadata: Metadata, options: Partial<CallOptions>, callback: (error: ServiceError | null, response: RollbackResponse) => void): ClientUnaryCall;
+}
+export declare const ServiceClient: {
+    new (address: string, credentials: ChannelCredentials, options?: Partial<ClientOptions>): ServiceClient;
+    service: typeof ServiceService;
+};

package/freym/migrations/management/service.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ServiceClient = exports.ServiceService = exports.protobufPackage = void 0;
+const grpc_js_1 = require("@grpc/grpc-js");
+const finish_1 = require("./finish");
+const register_1 = require("./register");
+const rollback_1 = require("./rollback");
+const start_1 = require("./start");
+const status_1 = require("./status");
+exports.protobufPackage = "freym.migrations.management";
+exports.ServiceService = {
+    register: {
+        path: "/freym.migrations.management.Service/Register",
+        requestStream: false,
+        responseStream: false,
+        requestSerialize: (value) => Buffer.from(register_1.RegisterRequest.encode(value).finish()),
+        requestDeserialize: (value) => register_1.RegisterRequest.decode(value),
+        responseSerialize: (value) => Buffer.from(register_1.RegisterResponse.encode(value).finish()),
+        responseDeserialize: (value) => register_1.RegisterResponse.decode(value),
+    },
+    status: {
+        path: "/freym.migrations.management.Service/Status",
+        requestStream: false,
+        responseStream: false,
+        requestSerialize: (value) => Buffer.from(status_1.StatusRequest.encode(value).finish()),
+        requestDeserialize: (value) => status_1.StatusRequest.decode(value),
+        responseSerialize: (value) => Buffer.from(status_1.StatusResponse.encode(value).finish()),
+        responseDeserialize: (value) => status_1.StatusResponse.decode(value),
+    },
+    start: {
+        path: "/freym.migrations.management.Service/Start",
+        requestStream: true,
+        responseStream: true,
+        requestSerialize: (value) => Buffer.from(start_1.StartRequest.encode(value).finish()),
+        requestDeserialize: (value) => start_1.StartRequest.decode(value),
+        responseSerialize: (value) => Buffer.from(start_1.StartResponse.encode(value).finish()),
+        responseDeserialize: (value) => start_1.StartResponse.decode(value),
+    },
+    finish: {
+        path: "/freym.migrations.management.Service/Finish",
+        requestStream: false,
+        responseStream: false,
+        requestSerialize: (value) => Buffer.from(finish_1.FinishRequest.encode(value).finish()),
+        requestDeserialize: (value) => finish_1.FinishRequest.decode(value),
+        responseSerialize: (value) => Buffer.from(finish_1.FinishResponse.encode(value).finish()),
+        responseDeserialize: (value) => finish_1.FinishResponse.decode(value),
+    },
+    rollback: {
+        path: "/freym.migrations.management.Service/Rollback",
+        requestStream: false,
+        responseStream: false,
+        requestSerialize: (value) => Buffer.from(rollback_1.RollbackRequest.encode(value).finish()),
+        requestDeserialize: (value) => rollback_1.RollbackRequest.decode(value),
+        responseSerialize: (value) => Buffer.from(rollback_1.RollbackResponse.encode(value).finish()),
+        responseDeserialize: (value) => rollback_1.RollbackResponse.decode(value),
+    },
+};
+exports.ServiceClient = (0, grpc_js_1.makeGenericClientConstructor)(exports.ServiceService, "freym.migrations.management.Service");

package/freym/migrations/management/start.d.ts

@@ -0,0 +1,136 @@
+import _m0 from "protobufjs/minimal";
+export declare const protobufPackage = "freym.migrations.management";
+export interface StartRequest {
+    payload?: {
+        $case: "init";
+        init: StartRequest_Init;
+    } | {
+        $case: "transformedData";
+        transformedData: StartRequest_TransformedData;
+    } | undefined;
+}
+export interface StartRequest_Init {
+    crudTypes: string[];
+}
+export interface StartRequest_TransformedData {
+    data: {
+        [key: string]: string;
+    };
+}
+export interface StartRequest_TransformedData_DataEntry {
+    key: string;
+    value: string;
+}
+export interface StartResponse {
+    data?: {
+        $case: "status";
+        status: StartResponse_Status;
+    } | {
+        $case: "transformData";
+        transformData: StartResponse_TransformData;
+    } | undefined;
+}
+export interface StartResponse_Status {
+    status: {
+        [key: string]: number;
+    };
+}
+export interface StartResponse_Status_StatusEntry {
+    key: string;
+    value: number;
+}
+export interface StartResponse_TransformData {
+    crudType: string;
+    tenantId: string;
+    id: string;
+    data: {
+        [key: string]: string;
+    };
+}
+export interface StartResponse_TransformData_DataEntry {
+    key: string;
+    value: string;
+}
+export declare const StartRequest: {
+    encode(message: StartRequest, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): StartRequest;
+    fromJSON(object: any): StartRequest;
+    toJSON(message: StartRequest): unknown;
+    create(base?: DeepPartial<StartRequest>): StartRequest;
+    fromPartial(object: DeepPartial<StartRequest>): StartRequest;
+};
+export declare const StartRequest_Init: {
+    encode(message: StartRequest_Init, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): StartRequest_Init;
+    fromJSON(object: any): StartRequest_Init;
+    toJSON(message: StartRequest_Init): unknown;
+    create(base?: DeepPartial<StartRequest_Init>): StartRequest_Init;
+    fromPartial(object: DeepPartial<StartRequest_Init>): StartRequest_Init;
+};
+export declare const StartRequest_TransformedData: {
+    encode(message: StartRequest_TransformedData, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): StartRequest_TransformedData;
+    fromJSON(object: any): StartRequest_TransformedData;
+    toJSON(message: StartRequest_TransformedData): unknown;
+    create(base?: DeepPartial<StartRequest_TransformedData>): StartRequest_TransformedData;
+    fromPartial(object: DeepPartial<StartRequest_TransformedData>): StartRequest_TransformedData;
+};
+export declare const StartRequest_TransformedData_DataEntry: {
+    encode(message: StartRequest_TransformedData_DataEntry, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): StartRequest_TransformedData_DataEntry;
+    fromJSON(object: any): StartRequest_TransformedData_DataEntry;
+    toJSON(message: StartRequest_TransformedData_DataEntry): unknown;
+    create(base?: DeepPartial<StartRequest_TransformedData_DataEntry>): StartRequest_TransformedData_DataEntry;
+    fromPartial(object: DeepPartial<StartRequest_TransformedData_DataEntry>): StartRequest_TransformedData_DataEntry;
+};
+export declare const StartResponse: {
+    encode(message: StartResponse, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): StartResponse;
+    fromJSON(object: any): StartResponse;
+    toJSON(message: StartResponse): unknown;
+    create(base?: DeepPartial<StartResponse>): StartResponse;
+    fromPartial(object: DeepPartial<StartResponse>): StartResponse;
+};
+export declare const StartResponse_Status: {
+    encode(message: StartResponse_Status, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): StartResponse_Status;
+    fromJSON(object: any): StartResponse_Status;
+    toJSON(message: StartResponse_Status): unknown;
+    create(base?: DeepPartial<StartResponse_Status>): StartResponse_Status;
+    fromPartial(object: DeepPartial<StartResponse_Status>): StartResponse_Status;
+};
+export declare const StartResponse_Status_StatusEntry: {
+    encode(message: StartResponse_Status_StatusEntry, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): StartResponse_Status_StatusEntry;
+    fromJSON(object: any): StartResponse_Status_StatusEntry;
+    toJSON(message: StartResponse_Status_StatusEntry): unknown;
+    create(base?: DeepPartial<StartResponse_Status_StatusEntry>): StartResponse_Status_StatusEntry;
+    fromPartial(object: DeepPartial<StartResponse_Status_StatusEntry>): StartResponse_Status_StatusEntry;
+};
+export declare const StartResponse_TransformData: {
+    encode(message: StartResponse_TransformData, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): StartResponse_TransformData;
+    fromJSON(object: any): StartResponse_TransformData;
+    toJSON(message: StartResponse_TransformData): unknown;
+    create(base?: DeepPartial<StartResponse_TransformData>): StartResponse_TransformData;
+    fromPartial(object: DeepPartial<StartResponse_TransformData>): StartResponse_TransformData;
+};
+export declare const StartResponse_TransformData_DataEntry: {
+    encode(message: StartResponse_TransformData_DataEntry, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): StartResponse_TransformData_DataEntry;
+    fromJSON(object: any): StartResponse_TransformData_DataEntry;
+    toJSON(message: StartResponse_TransformData_DataEntry): unknown;
+    create(base?: DeepPartial<StartResponse_TransformData_DataEntry>): StartResponse_TransformData_DataEntry;
+    fromPartial(object: DeepPartial<StartResponse_TransformData_DataEntry>): StartResponse_TransformData_DataEntry;
+};
+type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;
+export type DeepPartial<T> = T extends Builtin ? T : T extends Array<infer U> ? Array<DeepPartial<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>> : T extends {
+    $case: string;
+} ? {
+    [K in keyof Omit<T, "$case">]?: DeepPartial<T[K]>;
+} & {
+    $case: T["$case"];
+} : T extends {} ? {
+    [K in keyof T]?: DeepPartial<T[K]>;
+} : Partial<T>;
+export {};