mirror of
https://github.com/whyour/qinglong.git
synced 2025-11-10 00:26:09 +08:00
622 lines
16 KiB
TypeScript
622 lines
16 KiB
TypeScript
// Code generated by protoc-gen-ts_proto. DO NOT EDIT.
|
|
// versions:
|
|
// protoc-gen-ts_proto v2.6.1
|
|
// protoc v3.17.3
|
|
// source: back/protos/cron.proto
|
|
|
|
/* eslint-disable */
|
|
import { BinaryReader, BinaryWriter } from '@bufbuild/protobuf/wire';
|
|
import {
|
|
type CallOptions,
|
|
ChannelCredentials,
|
|
Client,
|
|
type ClientOptions,
|
|
type ClientUnaryCall,
|
|
type handleUnaryCall,
|
|
makeGenericClientConstructor,
|
|
Metadata,
|
|
type ServiceError,
|
|
type UntypedServiceImplementation,
|
|
} from '@grpc/grpc-js';
|
|
|
|
export const protobufPackage = 'com.ql.cron';
|
|
|
|
export interface ISchedule {
|
|
schedule: string;
|
|
}
|
|
|
|
export interface ICron {
|
|
id: string;
|
|
schedule: string;
|
|
command: string;
|
|
extra_schedules: ISchedule[];
|
|
name: string;
|
|
}
|
|
|
|
export interface AddCronRequest {
|
|
crons: ICron[];
|
|
}
|
|
|
|
export interface AddCronResponse {}
|
|
|
|
export interface DeleteCronRequest {
|
|
ids: string[];
|
|
}
|
|
|
|
export interface DeleteCronResponse {}
|
|
|
|
function createBaseISchedule(): ISchedule {
|
|
return { schedule: '' };
|
|
}
|
|
|
|
export const ISchedule: MessageFns<ISchedule> = {
|
|
encode(
|
|
message: ISchedule,
|
|
writer: BinaryWriter = new BinaryWriter(),
|
|
): BinaryWriter {
|
|
if (message.schedule !== '') {
|
|
writer.uint32(10).string(message.schedule);
|
|
}
|
|
return writer;
|
|
},
|
|
|
|
decode(input: BinaryReader | Uint8Array, length?: number): ISchedule {
|
|
const reader =
|
|
input instanceof BinaryReader ? input : new BinaryReader(input);
|
|
let end = length === undefined ? reader.len : reader.pos + length;
|
|
const message = createBaseISchedule();
|
|
while (reader.pos < end) {
|
|
const tag = reader.uint32();
|
|
switch (tag >>> 3) {
|
|
case 1: {
|
|
if (tag !== 10) {
|
|
break;
|
|
}
|
|
|
|
message.schedule = reader.string();
|
|
continue;
|
|
}
|
|
}
|
|
if ((tag & 7) === 4 || tag === 0) {
|
|
break;
|
|
}
|
|
reader.skip(tag & 7);
|
|
}
|
|
return message;
|
|
},
|
|
|
|
fromJSON(object: any): ISchedule {
|
|
return {
|
|
schedule: isSet(object.schedule)
|
|
? globalThis.String(object.schedule)
|
|
: '',
|
|
};
|
|
},
|
|
|
|
toJSON(message: ISchedule): unknown {
|
|
const obj: any = {};
|
|
if (message.schedule !== '') {
|
|
obj.schedule = message.schedule;
|
|
}
|
|
return obj;
|
|
},
|
|
|
|
create<I extends Exact<DeepPartial<ISchedule>, I>>(base?: I): ISchedule {
|
|
return ISchedule.fromPartial(base ?? ({} as any));
|
|
},
|
|
fromPartial<I extends Exact<DeepPartial<ISchedule>, I>>(
|
|
object: I,
|
|
): ISchedule {
|
|
const message = createBaseISchedule();
|
|
message.schedule = object.schedule ?? '';
|
|
return message;
|
|
},
|
|
};
|
|
|
|
function createBaseICron(): ICron {
|
|
return { id: '', schedule: '', command: '', extra_schedules: [], name: '' };
|
|
}
|
|
|
|
export const ICron: MessageFns<ICron> = {
|
|
encode(
|
|
message: ICron,
|
|
writer: BinaryWriter = new BinaryWriter(),
|
|
): BinaryWriter {
|
|
if (message.id !== '') {
|
|
writer.uint32(10).string(message.id);
|
|
}
|
|
if (message.schedule !== '') {
|
|
writer.uint32(18).string(message.schedule);
|
|
}
|
|
if (message.command !== '') {
|
|
writer.uint32(26).string(message.command);
|
|
}
|
|
for (const v of message.extra_schedules) {
|
|
ISchedule.encode(v!, writer.uint32(34).fork()).join();
|
|
}
|
|
if (message.name !== '') {
|
|
writer.uint32(42).string(message.name);
|
|
}
|
|
return writer;
|
|
},
|
|
|
|
decode(input: BinaryReader | Uint8Array, length?: number): ICron {
|
|
const reader =
|
|
input instanceof BinaryReader ? input : new BinaryReader(input);
|
|
let end = length === undefined ? reader.len : reader.pos + length;
|
|
const message = createBaseICron();
|
|
while (reader.pos < end) {
|
|
const tag = reader.uint32();
|
|
switch (tag >>> 3) {
|
|
case 1: {
|
|
if (tag !== 10) {
|
|
break;
|
|
}
|
|
|
|
message.id = reader.string();
|
|
continue;
|
|
}
|
|
case 2: {
|
|
if (tag !== 18) {
|
|
break;
|
|
}
|
|
|
|
message.schedule = reader.string();
|
|
continue;
|
|
}
|
|
case 3: {
|
|
if (tag !== 26) {
|
|
break;
|
|
}
|
|
|
|
message.command = reader.string();
|
|
continue;
|
|
}
|
|
case 4: {
|
|
if (tag !== 34) {
|
|
break;
|
|
}
|
|
|
|
message.extra_schedules.push(
|
|
ISchedule.decode(reader, reader.uint32()),
|
|
);
|
|
continue;
|
|
}
|
|
case 5: {
|
|
if (tag !== 42) {
|
|
break;
|
|
}
|
|
|
|
message.name = reader.string();
|
|
continue;
|
|
}
|
|
}
|
|
if ((tag & 7) === 4 || tag === 0) {
|
|
break;
|
|
}
|
|
reader.skip(tag & 7);
|
|
}
|
|
return message;
|
|
},
|
|
|
|
fromJSON(object: any): ICron {
|
|
return {
|
|
id: isSet(object.id) ? globalThis.String(object.id) : '',
|
|
schedule: isSet(object.schedule)
|
|
? globalThis.String(object.schedule)
|
|
: '',
|
|
command: isSet(object.command) ? globalThis.String(object.command) : '',
|
|
extra_schedules: globalThis.Array.isArray(object?.extra_schedules)
|
|
? object.extra_schedules.map((e: any) => ISchedule.fromJSON(e))
|
|
: [],
|
|
name: isSet(object.name) ? globalThis.String(object.name) : '',
|
|
};
|
|
},
|
|
|
|
toJSON(message: ICron): unknown {
|
|
const obj: any = {};
|
|
if (message.id !== '') {
|
|
obj.id = message.id;
|
|
}
|
|
if (message.schedule !== '') {
|
|
obj.schedule = message.schedule;
|
|
}
|
|
if (message.command !== '') {
|
|
obj.command = message.command;
|
|
}
|
|
if (message.extra_schedules?.length) {
|
|
obj.extra_schedules = message.extra_schedules.map((e) =>
|
|
ISchedule.toJSON(e),
|
|
);
|
|
}
|
|
if (message.name !== '') {
|
|
obj.name = message.name;
|
|
}
|
|
return obj;
|
|
},
|
|
|
|
create<I extends Exact<DeepPartial<ICron>, I>>(base?: I): ICron {
|
|
return ICron.fromPartial(base ?? ({} as any));
|
|
},
|
|
fromPartial<I extends Exact<DeepPartial<ICron>, I>>(object: I): ICron {
|
|
const message = createBaseICron();
|
|
message.id = object.id ?? '';
|
|
message.schedule = object.schedule ?? '';
|
|
message.command = object.command ?? '';
|
|
message.extra_schedules =
|
|
object.extra_schedules?.map((e) => ISchedule.fromPartial(e)) || [];
|
|
message.name = object.name ?? '';
|
|
return message;
|
|
},
|
|
};
|
|
|
|
function createBaseAddCronRequest(): AddCronRequest {
|
|
return { crons: [] };
|
|
}
|
|
|
|
export const AddCronRequest: MessageFns<AddCronRequest> = {
|
|
encode(
|
|
message: AddCronRequest,
|
|
writer: BinaryWriter = new BinaryWriter(),
|
|
): BinaryWriter {
|
|
for (const v of message.crons) {
|
|
ICron.encode(v!, writer.uint32(10).fork()).join();
|
|
}
|
|
return writer;
|
|
},
|
|
|
|
decode(input: BinaryReader | Uint8Array, length?: number): AddCronRequest {
|
|
const reader =
|
|
input instanceof BinaryReader ? input : new BinaryReader(input);
|
|
let end = length === undefined ? reader.len : reader.pos + length;
|
|
const message = createBaseAddCronRequest();
|
|
while (reader.pos < end) {
|
|
const tag = reader.uint32();
|
|
switch (tag >>> 3) {
|
|
case 1: {
|
|
if (tag !== 10) {
|
|
break;
|
|
}
|
|
|
|
message.crons.push(ICron.decode(reader, reader.uint32()));
|
|
continue;
|
|
}
|
|
}
|
|
if ((tag & 7) === 4 || tag === 0) {
|
|
break;
|
|
}
|
|
reader.skip(tag & 7);
|
|
}
|
|
return message;
|
|
},
|
|
|
|
fromJSON(object: any): AddCronRequest {
|
|
return {
|
|
crons: globalThis.Array.isArray(object?.crons)
|
|
? object.crons.map((e: any) => ICron.fromJSON(e))
|
|
: [],
|
|
};
|
|
},
|
|
|
|
toJSON(message: AddCronRequest): unknown {
|
|
const obj: any = {};
|
|
if (message.crons?.length) {
|
|
obj.crons = message.crons.map((e) => ICron.toJSON(e));
|
|
}
|
|
return obj;
|
|
},
|
|
|
|
create<I extends Exact<DeepPartial<AddCronRequest>, I>>(
|
|
base?: I,
|
|
): AddCronRequest {
|
|
return AddCronRequest.fromPartial(base ?? ({} as any));
|
|
},
|
|
fromPartial<I extends Exact<DeepPartial<AddCronRequest>, I>>(
|
|
object: I,
|
|
): AddCronRequest {
|
|
const message = createBaseAddCronRequest();
|
|
message.crons = object.crons?.map((e) => ICron.fromPartial(e)) || [];
|
|
return message;
|
|
},
|
|
};
|
|
|
|
function createBaseAddCronResponse(): AddCronResponse {
|
|
return {};
|
|
}
|
|
|
|
export const AddCronResponse: MessageFns<AddCronResponse> = {
|
|
encode(
|
|
_: AddCronResponse,
|
|
writer: BinaryWriter = new BinaryWriter(),
|
|
): BinaryWriter {
|
|
return writer;
|
|
},
|
|
|
|
decode(input: BinaryReader | Uint8Array, length?: number): AddCronResponse {
|
|
const reader =
|
|
input instanceof BinaryReader ? input : new BinaryReader(input);
|
|
let end = length === undefined ? reader.len : reader.pos + length;
|
|
const message = createBaseAddCronResponse();
|
|
while (reader.pos < end) {
|
|
const tag = reader.uint32();
|
|
switch (tag >>> 3) {
|
|
}
|
|
if ((tag & 7) === 4 || tag === 0) {
|
|
break;
|
|
}
|
|
reader.skip(tag & 7);
|
|
}
|
|
return message;
|
|
},
|
|
|
|
fromJSON(_: any): AddCronResponse {
|
|
return {};
|
|
},
|
|
|
|
toJSON(_: AddCronResponse): unknown {
|
|
const obj: any = {};
|
|
return obj;
|
|
},
|
|
|
|
create<I extends Exact<DeepPartial<AddCronResponse>, I>>(
|
|
base?: I,
|
|
): AddCronResponse {
|
|
return AddCronResponse.fromPartial(base ?? ({} as any));
|
|
},
|
|
fromPartial<I extends Exact<DeepPartial<AddCronResponse>, I>>(
|
|
_: I,
|
|
): AddCronResponse {
|
|
const message = createBaseAddCronResponse();
|
|
return message;
|
|
},
|
|
};
|
|
|
|
function createBaseDeleteCronRequest(): DeleteCronRequest {
|
|
return { ids: [] };
|
|
}
|
|
|
|
export const DeleteCronRequest: MessageFns<DeleteCronRequest> = {
|
|
encode(
|
|
message: DeleteCronRequest,
|
|
writer: BinaryWriter = new BinaryWriter(),
|
|
): BinaryWriter {
|
|
for (const v of message.ids) {
|
|
writer.uint32(10).string(v!);
|
|
}
|
|
return writer;
|
|
},
|
|
|
|
decode(input: BinaryReader | Uint8Array, length?: number): DeleteCronRequest {
|
|
const reader =
|
|
input instanceof BinaryReader ? input : new BinaryReader(input);
|
|
let end = length === undefined ? reader.len : reader.pos + length;
|
|
const message = createBaseDeleteCronRequest();
|
|
while (reader.pos < end) {
|
|
const tag = reader.uint32();
|
|
switch (tag >>> 3) {
|
|
case 1: {
|
|
if (tag !== 10) {
|
|
break;
|
|
}
|
|
|
|
message.ids.push(reader.string());
|
|
continue;
|
|
}
|
|
}
|
|
if ((tag & 7) === 4 || tag === 0) {
|
|
break;
|
|
}
|
|
reader.skip(tag & 7);
|
|
}
|
|
return message;
|
|
},
|
|
|
|
fromJSON(object: any): DeleteCronRequest {
|
|
return {
|
|
ids: globalThis.Array.isArray(object?.ids)
|
|
? object.ids.map((e: any) => globalThis.String(e))
|
|
: [],
|
|
};
|
|
},
|
|
|
|
toJSON(message: DeleteCronRequest): unknown {
|
|
const obj: any = {};
|
|
if (message.ids?.length) {
|
|
obj.ids = message.ids;
|
|
}
|
|
return obj;
|
|
},
|
|
|
|
create<I extends Exact<DeepPartial<DeleteCronRequest>, I>>(
|
|
base?: I,
|
|
): DeleteCronRequest {
|
|
return DeleteCronRequest.fromPartial(base ?? ({} as any));
|
|
},
|
|
fromPartial<I extends Exact<DeepPartial<DeleteCronRequest>, I>>(
|
|
object: I,
|
|
): DeleteCronRequest {
|
|
const message = createBaseDeleteCronRequest();
|
|
message.ids = object.ids?.map((e) => e) || [];
|
|
return message;
|
|
},
|
|
};
|
|
|
|
function createBaseDeleteCronResponse(): DeleteCronResponse {
|
|
return {};
|
|
}
|
|
|
|
export const DeleteCronResponse: MessageFns<DeleteCronResponse> = {
|
|
encode(
|
|
_: DeleteCronResponse,
|
|
writer: BinaryWriter = new BinaryWriter(),
|
|
): BinaryWriter {
|
|
return writer;
|
|
},
|
|
|
|
decode(
|
|
input: BinaryReader | Uint8Array,
|
|
length?: number,
|
|
): DeleteCronResponse {
|
|
const reader =
|
|
input instanceof BinaryReader ? input : new BinaryReader(input);
|
|
let end = length === undefined ? reader.len : reader.pos + length;
|
|
const message = createBaseDeleteCronResponse();
|
|
while (reader.pos < end) {
|
|
const tag = reader.uint32();
|
|
switch (tag >>> 3) {
|
|
}
|
|
if ((tag & 7) === 4 || tag === 0) {
|
|
break;
|
|
}
|
|
reader.skip(tag & 7);
|
|
}
|
|
return message;
|
|
},
|
|
|
|
fromJSON(_: any): DeleteCronResponse {
|
|
return {};
|
|
},
|
|
|
|
toJSON(_: DeleteCronResponse): unknown {
|
|
const obj: any = {};
|
|
return obj;
|
|
},
|
|
|
|
create<I extends Exact<DeepPartial<DeleteCronResponse>, I>>(
|
|
base?: I,
|
|
): DeleteCronResponse {
|
|
return DeleteCronResponse.fromPartial(base ?? ({} as any));
|
|
},
|
|
fromPartial<I extends Exact<DeepPartial<DeleteCronResponse>, I>>(
|
|
_: I,
|
|
): DeleteCronResponse {
|
|
const message = createBaseDeleteCronResponse();
|
|
return message;
|
|
},
|
|
};
|
|
|
|
export type CronService = typeof CronService;
|
|
export const CronService = {
|
|
addCron: {
|
|
path: '/com.ql.cron.Cron/addCron',
|
|
requestStream: false,
|
|
responseStream: false,
|
|
requestSerialize: (value: AddCronRequest) =>
|
|
Buffer.from(AddCronRequest.encode(value).finish()),
|
|
requestDeserialize: (value: Buffer) => AddCronRequest.decode(value),
|
|
responseSerialize: (value: AddCronResponse) =>
|
|
Buffer.from(AddCronResponse.encode(value).finish()),
|
|
responseDeserialize: (value: Buffer) => AddCronResponse.decode(value),
|
|
},
|
|
delCron: {
|
|
path: '/com.ql.cron.Cron/delCron',
|
|
requestStream: false,
|
|
responseStream: false,
|
|
requestSerialize: (value: DeleteCronRequest) =>
|
|
Buffer.from(DeleteCronRequest.encode(value).finish()),
|
|
requestDeserialize: (value: Buffer) => DeleteCronRequest.decode(value),
|
|
responseSerialize: (value: DeleteCronResponse) =>
|
|
Buffer.from(DeleteCronResponse.encode(value).finish()),
|
|
responseDeserialize: (value: Buffer) => DeleteCronResponse.decode(value),
|
|
},
|
|
} as const;
|
|
|
|
export interface CronServer extends UntypedServiceImplementation {
|
|
addCron: handleUnaryCall<AddCronRequest, AddCronResponse>;
|
|
delCron: handleUnaryCall<DeleteCronRequest, DeleteCronResponse>;
|
|
}
|
|
|
|
export interface CronClient extends Client {
|
|
addCron(
|
|
request: AddCronRequest,
|
|
callback: (error: ServiceError | null, response: AddCronResponse) => void,
|
|
): ClientUnaryCall;
|
|
addCron(
|
|
request: AddCronRequest,
|
|
metadata: Metadata,
|
|
callback: (error: ServiceError | null, response: AddCronResponse) => void,
|
|
): ClientUnaryCall;
|
|
addCron(
|
|
request: AddCronRequest,
|
|
metadata: Metadata,
|
|
options: Partial<CallOptions>,
|
|
callback: (error: ServiceError | null, response: AddCronResponse) => void,
|
|
): ClientUnaryCall;
|
|
delCron(
|
|
request: DeleteCronRequest,
|
|
callback: (
|
|
error: ServiceError | null,
|
|
response: DeleteCronResponse,
|
|
) => void,
|
|
): ClientUnaryCall;
|
|
delCron(
|
|
request: DeleteCronRequest,
|
|
metadata: Metadata,
|
|
callback: (
|
|
error: ServiceError | null,
|
|
response: DeleteCronResponse,
|
|
) => void,
|
|
): ClientUnaryCall;
|
|
delCron(
|
|
request: DeleteCronRequest,
|
|
metadata: Metadata,
|
|
options: Partial<CallOptions>,
|
|
callback: (
|
|
error: ServiceError | null,
|
|
response: DeleteCronResponse,
|
|
) => void,
|
|
): ClientUnaryCall;
|
|
}
|
|
|
|
export const CronClient = makeGenericClientConstructor(
|
|
CronService,
|
|
'com.ql.cron.Cron',
|
|
) as unknown as {
|
|
new (
|
|
address: string,
|
|
credentials: ChannelCredentials,
|
|
options?: Partial<ClientOptions>,
|
|
): CronClient;
|
|
service: typeof CronService;
|
|
serviceName: string;
|
|
};
|
|
|
|
type Builtin =
|
|
| Date
|
|
| Function
|
|
| Uint8Array
|
|
| string
|
|
| number
|
|
| boolean
|
|
| undefined;
|
|
|
|
export type DeepPartial<T> = T extends Builtin
|
|
? T
|
|
: T extends globalThis.Array<infer U>
|
|
? globalThis.Array<DeepPartial<U>>
|
|
: T extends ReadonlyArray<infer U>
|
|
? ReadonlyArray<DeepPartial<U>>
|
|
: T extends {}
|
|
? { [K in keyof T]?: DeepPartial<T[K]> }
|
|
: Partial<T>;
|
|
|
|
type KeysOfUnion<T> = T extends T ? keyof T : never;
|
|
export type Exact<P, I extends P> = P extends Builtin
|
|
? P
|
|
: P & { [K in keyof P]: Exact<P[K], I[K]> } & {
|
|
[K in Exclude<keyof I, KeysOfUnion<P>>]: never;
|
|
};
|
|
|
|
function isSet(value: any): boolean {
|
|
return value !== null && value !== undefined;
|
|
}
|
|
|
|
export interface MessageFns<T> {
|
|
encode(message: T, writer?: BinaryWriter): BinaryWriter;
|
|
decode(input: BinaryReader | Uint8Array, length?: number): T;
|
|
fromJSON(object: any): T;
|
|
toJSON(message: T): unknown;
|
|
create<I extends Exact<DeepPartial<T>, I>>(base?: I): T;
|
|
fromPartial<I extends Exact<DeepPartial<T>, I>>(object: I): T;
|
|
}
|