bet/beteran-frontend-app-browser
3
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

진행중...

Browse Source
This commit is contained in:
Park Byung Eun 2022-08-18 07:42:33 +00:00
parent 6cac14ec8a
commit 67fc3a7286
127 changed files with 52759 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

85
package-lock.json generated
View File

@ -23,9 +23,12 @@
"@ngneat/transloco": "3.1.4",
"apexcharts": "3.33.1",
"crypto-js": "3.3.0",
"google-protobuf": "^3.20.1",
"highlight.js": "11.4.0",
"js-base64": "^3.7.2",
"lodash-es": "4.17.21",
"moment": "2.29.1",
"nats.ws": "^1.8.1",
"ng-apexcharts": "1.7.0",
"ngx-markdown": "13.1.0",
"perfect-scrollbar": "1.5.3",
@ -48,6 +51,7 @@
"@tailwindcss/typography": "0.5.2",
"@types/chroma-js": "2.1.3",
"@types/crypto-js": "3.1.47",
"@types/google-protobuf": "^3.15.6",
"@types/highlight.js": "10.1.0",
"@types/jasmine": "3.10.3",
"@types/lodash": "4.14.178",
@ -3314,6 +3318,12 @@
"@types/range-parser": "*"
}
},
"node_modules/@types/google-protobuf": {
"version": "3.15.6",
"resolved": "https://registry.npmjs.org/@types/google-protobuf/-/google-protobuf-3.15.6.tgz",
"integrity": "sha512-pYVNNJ+winC4aek+lZp93sIKxnXt5qMkuKmaqS3WGuTq0Bw1ZDYNBgzG5kkdtwcv+GmYJGo3yEg6z2cKKAiEdw==",
"dev": true
},
"node_modules/@types/highlight.js": {
"version": "10.1.0",
"resolved": "https://registry.npmjs.org/@types/highlight.js/-/highlight.js-10.1.0.tgz",
@ -7769,6 +7779,11 @@
"node": ">=8.6.0"
}
},
"node_modules/google-protobuf": {
"version": "3.21.0",
"resolved": "https://registry.npmjs.org/google-protobuf/-/google-protobuf-3.21.0.tgz",
"integrity": "sha512-byR7MBTK4tZ5PZEb+u5ZTzpt4SfrTxv5682MjPlHN16XeqgZE2/8HOIWeiXe8JKnT9OVbtBGhbq8mtvkK8cd5g=="
},
"node_modules/graceful-fs": {
"version": "4.2.9",
"resolved": "https://registry.npmjs.org/graceful-fs/-/graceful-fs-4.2.9.tgz",
@ -8884,6 +8899,11 @@
"url": "https://github.com/chalk/supports-color?sponsor=1"
}
},
"node_modules/js-base64": {
"version": "3.7.2",
"resolved": "https://registry.npmjs.org/js-base64/-/js-base64-3.7.2.tgz",
"integrity": "sha512-NnRs6dsyqUXejqk/yv2aiXlAvOs56sLkX6nUdeaNezI5LFFLlsZjOThmwnrcwh5ZZRwZlCMnVAY3CvhIhoVEKQ=="
},
"node_modules/js-tokens": {
"version": "4.0.0",
"resolved": "https://registry.npmjs.org/js-tokens/-/js-tokens-4.0.0.tgz",
@ -9946,6 +9966,14 @@
"node": "^10 || ^12 || ^13.7 || ^14 || >=15.0.1"
}
},
"node_modules/nats.ws": {
"version": "1.8.1",
"resolved": "https://registry.npmjs.org/nats.ws/-/nats.ws-1.8.1.tgz",
"integrity": "sha512-7p1GkLfHTb42KX0wWZNEVEefYRQhsknE6tptMmr8oNzYA5gZ2BaZGQgXF+JUU9pBU6K+fVsClOrXt8nRugwDMg==",
"optionalDependencies": {
"nkeys.js": "^1.0.0-9"
}
},
"node_modules/natural-compare": {
"version": "1.4.0",
"resolved": "https://registry.npmjs.org/natural-compare/-/natural-compare-1.4.0.tgz",
@ -10044,6 +10072,18 @@
"node-gyp-build": "^4.2.2"
}
},
"node_modules/nkeys.js": {
"version": "1.0.3",
"resolved": "https://registry.npmjs.org/nkeys.js/-/nkeys.js-1.0.3.tgz",
"integrity": "sha512-p5Bpb/acPaQmCrbe4gNmMBY/naZJV8Q7m2B9UkXT8BQRC6wjX8zqD2ya8eZu9mpSXQffodV46HCP9OckmxcwYA==",
"optional": true,
"dependencies": {
"tweetnacl": "1.0.3"
},
"engines": {
"node": ">=10.0.0"
}
},
"node_modules/node-addon-api": {
"version": "3.2.1",
"resolved": "https://registry.npmjs.org/node-addon-api/-/node-addon-api-3.2.1.tgz",
@ -13537,6 +13577,12 @@
"integrity": "sha512-Xni35NKzjgMrwevysHTCArtLDpPvye8zV/0E4EyYn43P7/7qvQwPh9BGkHewbMulVntbigmcT7rdX3BNo9wRJg==",
"dev": true
},
"node_modules/tweetnacl": {
"version": "1.0.3",
"resolved": "https://registry.npmjs.org/tweetnacl/-/tweetnacl-1.0.3.tgz",
"integrity": "sha512-6rt+RN7aOi1nGMyC4Xa5DdYiukl2UWCbcJft7YhxReBGQD7OAM8Pbxw6YMo4r2diNEA8FEmu32YOn9rhaiE5yw==",
"optional": true
},
"node_modules/type-check": {
"version": "0.4.0",
"resolved": "https://registry.npmjs.org/type-check/-/type-check-0.4.0.tgz",
@ -16696,6 +16742,12 @@
"@types/range-parser": "*"
}
},
"@types/google-protobuf": {
"version": "3.15.6",
"resolved": "https://registry.npmjs.org/@types/google-protobuf/-/google-protobuf-3.15.6.tgz",
"integrity": "sha512-pYVNNJ+winC4aek+lZp93sIKxnXt5qMkuKmaqS3WGuTq0Bw1ZDYNBgzG5kkdtwcv+GmYJGo3yEg6z2cKKAiEdw==",
"dev": true
},
"@types/highlight.js": {
"version": "10.1.0",
"resolved": "https://registry.npmjs.org/@types/highlight.js/-/highlight.js-10.1.0.tgz",
@ -19974,6 +20026,11 @@
}
}
},
"google-protobuf": {
"version": "3.21.0",
"resolved": "https://registry.npmjs.org/google-protobuf/-/google-protobuf-3.21.0.tgz",
"integrity": "sha512-byR7MBTK4tZ5PZEb+u5ZTzpt4SfrTxv5682MjPlHN16XeqgZE2/8HOIWeiXe8JKnT9OVbtBGhbq8mtvkK8cd5g=="
},
"graceful-fs": {
"version": "4.2.9",
"resolved": "https://registry.npmjs.org/graceful-fs/-/graceful-fs-4.2.9.tgz",
@ -20784,6 +20841,11 @@
}
}
},
"js-base64": {
"version": "3.7.2",
"resolved": "https://registry.npmjs.org/js-base64/-/js-base64-3.7.2.tgz",
"integrity": "sha512-NnRs6dsyqUXejqk/yv2aiXlAvOs56sLkX6nUdeaNezI5LFFLlsZjOThmwnrcwh5ZZRwZlCMnVAY3CvhIhoVEKQ=="
},
"js-tokens": {
"version": "4.0.0",
"resolved": "https://registry.npmjs.org/js-tokens/-/js-tokens-4.0.0.tgz",
@ -21580,6 +21642,14 @@
"integrity": "sha512-n6Vs/3KGyxPQd6uO0eH4Bv0ojGSUvuLlIHtC3Y0kEO23YRge8H9x1GCzLn28YX0H66pMkxuaeESFq4tKISKwdw==",
"dev": true
},
"nats.ws": {
"version": "1.8.1",
"resolved": "https://registry.npmjs.org/nats.ws/-/nats.ws-1.8.1.tgz",
"integrity": "sha512-7p1GkLfHTb42KX0wWZNEVEefYRQhsknE6tptMmr8oNzYA5gZ2BaZGQgXF+JUU9pBU6K+fVsClOrXt8nRugwDMg==",
"requires": {
"nkeys.js": "^1.0.0-9"
}
},
"natural-compare": {
"version": "1.4.0",
"resolved": "https://registry.npmjs.org/natural-compare/-/natural-compare-1.4.0.tgz",
@ -21654,6 +21724,15 @@
"node-gyp-build": "^4.2.2"
}
},
"nkeys.js": {
"version": "1.0.3",
"resolved": "https://registry.npmjs.org/nkeys.js/-/nkeys.js-1.0.3.tgz",
"integrity": "sha512-p5Bpb/acPaQmCrbe4gNmMBY/naZJV8Q7m2B9UkXT8BQRC6wjX8zqD2ya8eZu9mpSXQffodV46HCP9OckmxcwYA==",
"optional": true,
"requires": {
"tweetnacl": "1.0.3"
}
},
"node-addon-api": {
"version": "3.2.1",
"resolved": "https://registry.npmjs.org/node-addon-api/-/node-addon-api-3.2.1.tgz",
@ -24216,6 +24295,12 @@
}
}
},
"tweetnacl": {
"version": "1.0.3",
"resolved": "https://registry.npmjs.org/tweetnacl/-/tweetnacl-1.0.3.tgz",
"integrity": "sha512-6rt+RN7aOi1nGMyC4Xa5DdYiukl2UWCbcJft7YhxReBGQD7OAM8Pbxw6YMo4r2diNEA8FEmu32YOn9rhaiE5yw==",
"optional": true
},
"type-check": {
"version": "0.4.0",
"resolved": "https://registry.npmjs.org/type-check/-/type-check-0.4.0.tgz",

4
package.json
View File

@ -28,9 +28,12 @@
"@ngneat/transloco": "3.1.4",
"apexcharts": "3.33.1",
"crypto-js": "3.3.0",
"google-protobuf": "^3.20.1",
"highlight.js": "11.4.0",
"js-base64": "^3.7.2",
"lodash-es": "4.17.21",
"moment": "2.29.1",
"nats.ws": "^1.8.1",
"ng-apexcharts": "1.7.0",
"ngx-markdown": "13.1.0",
"perfect-scrollbar": "1.5.3",
@ -53,6 +56,7 @@
"@tailwindcss/typography": "0.5.2",
"@types/chroma-js": "2.1.3",
"@types/crypto-js": "3.1.47",
"@types/google-protobuf": "^3.15.6",
"@types/highlight.js": "10.1.0",
"@types/jasmine": "3.10.3",
"@types/lodash": "4.14.178",

12
src/app/app.module.ts
View File

@ -13,6 +13,18 @@ import { LayoutModule } from 'app/layout/layout.module';
import { AppComponent } from 'app/app.component';
import { appRoutes } from 'app/app.routing';
import { BankModule } from 'app/modules/polyglot/bank/bank.module';
import { IdentityModule } from 'app/modules/polyglot/identity/identity.module';
import { MemberBankAccountModule } from 'app/modules/polyglot/member_bank_account/member_bank_account.module';
import { MemberBankDepositModule } from 'app/modules/polyglot/member_bank_deposit/member_bank_deposit.module';
import { MemberBankWithdrawModule } from 'app/modules/polyglot/member_bank_withdraw/member_bank_withdraw.module';
import { MemberClassModule } from 'app/modules/polyglot/member_class/member_class.module';
import { MemberLevelModule } from 'app/modules/polyglot/member_level/member_level.module';
import { MemberModule } from 'app/modules/polyglot/member/member.module';
import { SiteModule } from 'app/modules/polyglot/site/site.module';
import { ApiModule } from 'app/modules/polyglot/api/api.module';
const routerConfig: ExtraOptions = {
preloadingStrategy: PreloadAllModules,
scrollPositionRestoration: 'enabled',

5
src/app/core/nats/config/module-config.ts Normal file
View File

@ -0,0 +1,5 @@
import * as nats from 'nats.ws';
export interface ModuleConfig {
connectionOptions: nats.ConnectionOptions;
}

5
src/app/core/nats/config/token.ts Normal file
View File

@ -0,0 +1,5 @@
import { InjectionToken } from '@angular/core';
export const _MODULE_CONFIG = new InjectionToken(
'@bet/beteran nats config of module'
);

35
src/app/core/nats/nats.module.ts Normal file
View File

@ -0,0 +1,35 @@
import { APP_INITIALIZER, ModuleWithProviders, NgModule } from '@angular/core';
import { ModuleConfig } from './config/module-config';
import { _MODULE_CONFIG } from './config/token';
import { SERVICES } from './services';
import { NatsService } from './services/nats.service';
@NgModule({})
export class NatsRootModule {}
@NgModule({})
export class NatsModule {
public static forRoot(
config: ModuleConfig
): ModuleWithProviders<NatsRootModule> {
return {
ngModule: NatsRootModule,
providers: [
{ provide: _MODULE_CONFIG, useValue: config },
{
// Preload the default language before the app starts to prevent empty/jumping content
provide: APP_INITIALIZER,
deps: [NatsService],
useFactory:
(natsService: NatsService): any =>
(): Promise<void> => {
return natsService.connect();
},
multi: true,
},
...SERVICES,
],
};
}
}

5
src/app/core/nats/services/index.ts Normal file
View File

@ -0,0 +1,5 @@
import { Type } from '@angular/core';
import { NatsService } from './nats.service';
export const SERVICES: Type<any>[] = [NatsService];

122
src/app/core/nats/services/nats.service.ts Normal file
View File

@ -0,0 +1,122 @@
import { Inject, Injectable, OnInit, Type } from '@angular/core';
import { DOCUMENT } from '@angular/common';
import * as jspb from 'google-protobuf';
import * as nats from 'nats.ws';
import { Base64 } from 'js-base64';
import { HEADER_CLIENT } from 'app/modules/proto/c2se/core/network_pb';
import { Client } from 'app/modules/proto/models/core/network_pb';
import { ModuleConfig } from '../config/module-config';
import { _MODULE_CONFIG } from '../config/token';
import { WebSessionStorageService } from 'app/core/web-storage/services/web-session-storage.service';
type DeserializeConstructor<T> = {
new (): T;
deserializeBinary(this: DeserializeConstructor<T>, bytes: Uint8Array): T;
};
const NAME_GET_ERROR = 'getError';
const NAME_GET_RESULT = 'getResult';
@Injectable({
providedIn: 'root',
})
export class NatsService {
private __conn?: nats.NatsConnection;
/**
* Constructor
*/
constructor(
@Inject(_MODULE_CONFIG) private __config: ModuleConfig,
@Inject(DOCUMENT) private __document: Document,
private __webSessionStorageService: WebSessionStorageService
) {}
ngOnInit(): void {}
// -----------------------------------------------------------------------------------------------------
// @ Accessors
// -----------------------------------------------------------------------------------------------------
get connection(): nats.NatsConnection | undefined {
return this.__conn;
}
// -----------------------------------------------------------------------------------------------------
// @ Public methods
// -----------------------------------------------------------------------------------------------------
connect(): Promise<void> {
return new Promise<void>((resolve, reject) => {
if (!!this.__conn) {
return resolve();
}
nats
.connect(this.__config.connectionOptions)
.then((conn) => {
console.log('NATS connected', conn.info?.client_ip);
this.__conn = conn;
this.__webSessionStorageService
.watch('accessToken')
.subscribe((accessToken) => {
console.log('accessToken in NatsService', accessToken);
});
resolve();
})
.catch((e) => {
reject(e);
});
});
}
request<R>(
subject: string,
req: Uint8Array,
deserialize: (data: Uint8Array) => any,
opts?: nats.RequestOptions | undefined
): Promise<R> {
return new Promise<R>((resolve, reject) => {
let c = new Client();
c.setClientIp(this.__conn?.info?.client_ip + '');
c.setAccessToken(this.__webSessionStorageService.get('accessToken'));
c.setSiteUrl(this.__document.location.hostname);
let _opts: nats.RequestOptions = !!opts ? opts : { timeout: 3000 };
if (!_opts.headers) {
_opts.headers = nats.headers();
}
_opts.headers.append(
HEADER_CLIENT,
Base64.fromUint8Array(c.serializeBinary())
);
this.__conn?.request(subject, req, _opts).then((msg) => {
let res = deserialize(msg.data);
let get_error = (res as any)[NAME_GET_ERROR];
if (!!get_error) {
let error = get_error.call(res);
if (!!error) {
return reject(error);
}
}
let get_result = (res as any)[NAME_GET_RESULT];
if (!!get_result) {
let result = get_result.call(res);
if (!result) {
return reject('result is not exist');
}
return resolve(result);
}
return reject('protocol error');
});
});
}
}

1
src/app/core/web-storage/config/module-config.ts Normal file
View File

@ -0,0 +1 @@
export interface ModuleConfig {}

5
src/app/core/web-storage/config/token.ts Normal file
View File

@ -0,0 +1,5 @@
import { InjectionToken } from '@angular/core';
export const _MODULE_CONFIG = new InjectionToken(
'@bet/beteran web-storage config of module'
);

9
src/app/core/web-storage/services/index.ts Normal file
View File

@ -0,0 +1,9 @@
import { Type } from '@angular/core';
import { WebLocalStorageService } from './web-local-storage.service';
import { WebSessionStorageService } from './web-session-storage.service';
export const SERVICES: Type<any>[] = [
WebLocalStorageService,
WebSessionStorageService,
];

25
src/app/core/web-storage/services/web-local-storage.service.ts Normal file
View File

@ -0,0 +1,25 @@
import { Inject, Injectable } from '@angular/core';
import { ModuleConfig } from '../config/module-config';
import { _MODULE_CONFIG } from '../config/token';
import { WebStorageService } from './web-storage.service';
@Injectable({
providedIn: 'root',
})
export class WebLocalStorageService extends WebStorageService {
/**
* Constructor
*/
constructor() {
super(localStorage);
}
// -----------------------------------------------------------------------------------------------------
// @ Accessors
// -----------------------------------------------------------------------------------------------------
// -----------------------------------------------------------------------------------------------------
// @ Public methods
// -----------------------------------------------------------------------------------------------------
}

25
src/app/core/web-storage/services/web-session-storage.service.ts Normal file
View File

@ -0,0 +1,25 @@
import { Inject, Injectable } from '@angular/core';
import { ModuleConfig } from '../config/module-config';
import { _MODULE_CONFIG } from '../config/token';
import { WebStorageService } from './web-storage.service';
@Injectable({
providedIn: 'root',
})
export class WebSessionStorageService extends WebStorageService {
/**
* Constructor
*/
constructor() {
super(sessionStorage);
}
// -----------------------------------------------------------------------------------------------------
// @ Accessors
// -----------------------------------------------------------------------------------------------------
// -----------------------------------------------------------------------------------------------------
// @ Public methods
// -----------------------------------------------------------------------------------------------------
}

88
src/app/core/web-storage/services/web-storage.service.ts Normal file
View File

@ -0,0 +1,88 @@
import { BehaviorSubject, Observable } from 'rxjs';
import { ModuleConfig } from '../config/module-config';
import { _MODULE_CONFIG } from '../config/token';
export abstract class WebStorageService {
private __storage: Storage;
private __subjects: Map<string, BehaviorSubject<any>>;
/**
* Constructor
*/
constructor(storage: Storage) {
this.__storage = storage;
this.__subjects = new Map<string, BehaviorSubject<any>>();
}
// -----------------------------------------------------------------------------------------------------
// @ Accessors
// -----------------------------------------------------------------------------------------------------
// -----------------------------------------------------------------------------------------------------
// @ Public methods
// -----------------------------------------------------------------------------------------------------
/**
* watch data of given key
* @param key
* @param defaultValue
*/
watch(key: string, defaultValue: any = null): Observable<any> {
if (!this.__subjects.has(key)) {
this.__subjects.set(key, new BehaviorSubject<any>(defaultValue));
}
let item = this.__storage.getItem(key);
if (item !== null) {
item = JSON.parse(item);
}
(this.__subjects.get(key) as BehaviorSubject<any>).next(item);
return (this.__subjects.get(key) as BehaviorSubject<any>).asObservable();
}
/**
* get data of given key
* @param key
*/
get(key: string): any {
let item = this.__storage.getItem(key);
if (item !== null) {
item = JSON.parse(item);
}
return item;
}
/**
* set value on given key
* @param key
* @param value
*/
set(key: string, value: any) {
this.__storage.setItem(key, JSON.stringify(value));
if (!this.__subjects.has(key)) {
this.__subjects.set(key, new BehaviorSubject<any>(value));
(this.__subjects.get(key) as BehaviorSubject<any>).next(value);
} else {
(this.__subjects.get(key) as BehaviorSubject<any>).next(value);
}
}
/**
* remove given key
* @param key
*/
remove(key: string) {
if (this.__subjects.has(key)) {
(this.__subjects.get(key) as BehaviorSubject<any>).complete();
this.__subjects.delete(key);
}
this.__storage.removeItem(key);
}
/**
* clear all available keys
*/
clear() {
this.__subjects.clear();
this.__storage.clear();
}
}

20
src/app/core/web-storage/web-storage.module.ts Normal file
View File

@ -0,0 +1,20 @@
import { ModuleWithProviders, NgModule } from '@angular/core';
import { ModuleConfig } from './config/module-config';
import { _MODULE_CONFIG } from './config/token';
import { SERVICES } from './services';
@NgModule({})
export class WebStorageRootModule {}
@NgModule({})
export class WebStorageModule {
public static forRoot(
config: ModuleConfig
): ModuleWithProviders<WebStorageRootModule> {
return {
ngModule: WebStorageRootModule,
providers: [{ provide: _MODULE_CONFIG, useValue: config }, ...SERVICES],
};
}
}

16
src/app/modules/polyglot/api/api.module.ts Normal file
View File

@ -0,0 +1,16 @@
import { ModuleWithProviders, NgModule } from '@angular/core';
import { SERVICES } from './services';
@NgModule({})
export class ApiRootModule {}
@NgModule({})
export class ApiModule {
public static forRoot(): ModuleWithProviders<ApiRootModule> {
return {
ngModule: ApiRootModule,
providers: [...SERVICES],
};
}
}

49
src/app/modules/polyglot/api/services/api.service.ts Normal file
View File

@ -0,0 +1,49 @@
import { Injectable } from '@angular/core';
import { NatsService } from 'app/core/nats/services/nats.service';
import { Error } from 'app/modules/proto/protobuf/rpc_pb';
import {
ListVendorsRequest,
ListVendorsResponse,
} from 'app/modules/proto/c2se/api/vendor_pb';
import { SUBJECT_LIST_VENDORS } from 'app/modules/proto/c2se/backend/api/vendor_pb';
@Injectable({
providedIn: 'root',
})
export class ApiService {
/**
* Constructor
*/
constructor(private __natsService: NatsService) {}
// -----------------------------------------------------------------------------------------------------
// @ Accessors
// -----------------------------------------------------------------------------------------------------
// -----------------------------------------------------------------------------------------------------
// @ Public methods
// -----------------------------------------------------------------------------------------------------
listBanks(): Promise<ListVendorsResponse.Result> {
return new Promise<ListVendorsResponse.Result>((resolve, reject) => {
let req = new ListVendorsRequest();
this.__natsService
.request<ListVendorsResponse.Result>(
SUBJECT_LIST_VENDORS,
req.serializeBinary(),
ListVendorsResponse.deserializeBinary
)
.then((result) => {
console.log('success', result, result.getVendorsList());
return resolve(result);
})
.catch((e: Error) => {
console.log('failed', e);
reject(e);
});
});
}
}

5
src/app/modules/polyglot/api/services/index.ts Normal file
View File

@ -0,0 +1,5 @@
import { Type } from '@angular/core';
import { ApiService } from './api.service';
export const SERVICES: Type<any>[] = [ApiService];

16
src/app/modules/polyglot/bank/bank.module.ts Normal file
View File

@ -0,0 +1,16 @@
import { ModuleWithProviders, NgModule } from '@angular/core';
import { SERVICES } from './services';
@NgModule({})
export class BankRootModule {}
@NgModule({})
export class BankModule {
public static forRoot(): ModuleWithProviders<BankRootModule> {
return {
ngModule: BankRootModule,
providers: [...SERVICES],
};
}
}

148
src/app/modules/polyglot/bank/services/bank.service.ts Normal file
View File

@ -0,0 +1,148 @@
import { Injectable } from '@angular/core';
import { NatsService } from 'app/core/nats/services/nats.service';
import * as nats from 'nats.ws';
import { Error } from 'app/modules/proto/protobuf/rpc_pb';
import {
ListBanksRequest,
ListBanksResponse,
CreateBankRequest,
CreateBankResponse,
UpdateBankRequest,
UpdateBankResponse,
DeleteBankRequest,
DeleteBankResponse,
GetBankResponse,
GetBankRequest,
} from 'app/modules/proto/c2se/bank_pb';
import {
SUBJECT_LIST_BANKS,
SUBJECT_CREATE_BANK,
SUBJECT_UPDATE_BANK,
SUBJECT_DELETE_BANK,
SUBJECT_GET_BANK,
} from 'app/modules/proto/c2se/backend/bank_pb';
@Injectable({
providedIn: 'root',
})
export class BankService {
/**
* Constructor
*/
constructor(private __natsService: NatsService) {}
// -----------------------------------------------------------------------------------------------------
// @ Accessors
// -----------------------------------------------------------------------------------------------------
// -----------------------------------------------------------------------------------------------------
// @ Public methods
// -----------------------------------------------------------------------------------------------------
createBank(): Promise<CreateBankResponse.Result> {
return new Promise<CreateBankResponse.Result>((resolve, reject) => {
let req = new CreateBankRequest();
this.__natsService
.request<CreateBankResponse.Result>(
SUBJECT_CREATE_BANK,
req.serializeBinary(),
CreateBankResponse.deserializeBinary
)
.then((result) => {
console.log('success', result, result.getBank());
return resolve(result);
})
.catch((e: Error) => {
console.log('failed', e);
return reject(e);
});
});
}
listBanks(): Promise<ListBanksResponse.Result> {
return new Promise<ListBanksResponse.Result>((resolve, reject) => {
let req = new ListBanksRequest();
this.__natsService
.request<ListBanksResponse.Result>(
SUBJECT_LIST_BANKS,
req.serializeBinary(),
ListBanksResponse.deserializeBinary
)
.then((result) => {
console.log('success', result, result.getBanksList());
return resolve(result);
})
.catch((e: Error) => {
console.log('failed', e);
reject(e);
});
});
}
getBank(): Promise<GetBankResponse.Result> {
return new Promise<GetBankResponse.Result>((resolve, reject) => {
let req = new GetBankRequest();
this.__natsService
.request<GetBankResponse.Result>(
SUBJECT_GET_BANK,
req.serializeBinary(),
GetBankResponse.deserializeBinary
)
.then((result) => {
console.log('success', result, result.getBank());
return resolve(result);
})
.catch((e: Error) => {
console.log('failed', e);
return reject(e);
});
});
}
updateBank(): Promise<UpdateBankResponse.Result> {
return new Promise<UpdateBankResponse.Result>((resolve, reject) => {
let req = new UpdateBankRequest();
this.__natsService
.request<UpdateBankResponse.Result>(
SUBJECT_UPDATE_BANK,
req.serializeBinary(),
UpdateBankResponse.deserializeBinary
)
.then((result) => {
console.log('success', result, result.getBank());
return resolve(result);
})
.catch((e: Error) => {
console.log('failed', e);
return reject(e);
});
});
}
deleteBank(): Promise<DeleteBankResponse.Result> {
return new Promise<DeleteBankResponse.Result>((resolve, reject) => {
let req = new DeleteBankRequest();
this.__natsService
.request<DeleteBankResponse.Result>(
SUBJECT_DELETE_BANK,
req.serializeBinary(),
DeleteBankResponse.deserializeBinary
)
.then((result) => {
console.log('success', result);
return resolve(result);
})
.catch((e: Error) => {
console.log('failed', e);
return reject(e);
});
});
}
}

5
src/app/modules/polyglot/bank/services/index.ts Normal file
View File

@ -0,0 +1,5 @@
import { Type } from '@angular/core';
import { BankService } from './bank.service';
export const SERVICES: Type<any>[] = [BankService];

16
src/app/modules/polyglot/identity/identity.module.ts Normal file
View File

@ -0,0 +1,16 @@
import { ModuleWithProviders, NgModule } from '@angular/core';
import { SERVICES } from './services';
@NgModule({})
export class IdentityRootModule {}
@NgModule({})
export class IdentityModule {
public static forRoot(): ModuleWithProviders<IdentityRootModule> {
return {
ngModule: IdentityRootModule,
providers: [...SERVICES],
};
}
}

133
src/app/modules/polyglot/identity/services/identity.service.ts Normal file
View File

@ -0,0 +1,133 @@
import { Injectable } from '@angular/core';
import { NatsService } from 'app/core/nats/services/nats.service';
import * as nats from 'nats.ws';
import { Error } from 'app/modules/proto/protobuf/rpc_pb';
import {
CheckUsernameForDuplicationRequest,
CheckUsernameForDuplicationResponse,
CheckNicknameForDuplicationRequest,
CheckNicknameForDuplicationResponse,
CaptchaRequest,
CaptchaResponse,
SigninRequest,
SigninResponse,
} from 'app/modules/proto/c2se/identity_pb';
import {
SUBJECT_CHECK_USERNAME_FOR_DUPLICATION,
SUBJECT_CHECK_NICKNAME_FOR_DUPLICATION,
SUBJECT_CAPTCHA,
SUBJECT_SIGNIN,
} from 'app/modules/proto/c2se/backend/identity_pb';
@Injectable({
providedIn: 'root',
})
export class IdentityService {
/**
* Constructor
*/
constructor(private __natsService: NatsService) {}
// -----------------------------------------------------------------------------------------------------
// @ Accessors
// -----------------------------------------------------------------------------------------------------
// -----------------------------------------------------------------------------------------------------
// @ Public methods
// -----------------------------------------------------------------------------------------------------
checkUsernameForDuplication(username: string): Promise<boolean> {
return new Promise<boolean>((resolve, reject) => {
let req = new CheckUsernameForDuplicationRequest();
req.setUsername(username);
this.__natsService
.request<CheckUsernameForDuplicationResponse.Result>(
SUBJECT_CHECK_USERNAME_FOR_DUPLICATION,
req.serializeBinary(),
CheckUsernameForDuplicationResponse.deserializeBinary
)
.then((result) => {
console.log('success', result, result.getDuplicated());
resolve(result.getDuplicated());
})
.catch((e: Error) => {
console.log('failed', e);
reject(e);
});
});
}
checkNicknameForDuplication(nickname: string): Promise<boolean> {
return new Promise<boolean>((resolve, reject) => {
let req = new CheckNicknameForDuplicationRequest();
req.setNickname(nickname);
this.__natsService
.request<CheckNicknameForDuplicationResponse.Result>(
SUBJECT_CHECK_NICKNAME_FOR_DUPLICATION,
req.serializeBinary(),
CheckNicknameForDuplicationResponse.deserializeBinary
)
.then((result) => {
console.log('success', result, result.getDuplicated());
resolve(result.getDuplicated());
})
.catch((e: Error) => {
console.log('failed', e);
reject(e);
});
});
}
captcha(): Promise<CaptchaResponse.Result> {
return new Promise<CaptchaResponse.Result>((resolve, reject) => {
let req = new CaptchaRequest();
this.__natsService
.request<CaptchaResponse.Result>(
SUBJECT_CAPTCHA,
req.serializeBinary(),
CaptchaResponse.deserializeBinary
)
.then((result) => {
resolve(result);
})
.catch((e: Error) => {
console.log('failed', e);
reject(e);
});
});
}
signin(
securityCodeHash: string,
securityCode: string,
username: string,
password: string
): Promise<SigninResponse.Result> {
return new Promise<SigninResponse.Result>((resolve, reject) => {
let req = new SigninRequest();
req.setSecurityCodeHash(securityCodeHash);
req.setSecurityCode(securityCode);
req.setUsername(username);
req.setPassword(password);
this.__natsService
.request<SigninResponse.Result>(
SUBJECT_SIGNIN,
req.serializeBinary(),
SigninResponse.deserializeBinary
)
.then((result) => {
resolve(result);
})
.catch((e: Error) => {
console.log('failed', e);
reject(e);
});
});
}
}

5
src/app/modules/polyglot/identity/services/index.ts Normal file
View File

@ -0,0 +1,5 @@
import { Type } from '@angular/core';
import { IdentityService } from './identity.service';
export const SERVICES: Type<any>[] = [IdentityService];

16
src/app/modules/polyglot/member/member.module.ts Normal file
View File

@ -0,0 +1,16 @@
import { ModuleWithProviders, NgModule } from '@angular/core';
import { SERVICES } from './services';
@NgModule({})
export class MemberRootModule {}
@NgModule({})
export class MemberModule {
public static forRoot(): ModuleWithProviders<MemberRootModule> {
return {
ngModule: MemberRootModule,
providers: [...SERVICES],
};
}
}

5
src/app/modules/polyglot/member/services/index.ts Normal file
View File

@ -0,0 +1,5 @@
import { Type } from '@angular/core';
import { MemberService } from './member.service';
export const SERVICES: Type<any>[] = [MemberService];

183
src/app/modules/polyglot/member/services/member.service.ts Normal file
View File

@ -0,0 +1,183 @@
import { Injectable } from '@angular/core';
import { NatsService } from 'app/core/nats/services/nats.service';
import * as nats from 'nats.ws';
import { Error } from 'app/modules/proto/protobuf/rpc_pb';
import {
ListMembersRequest,
ListMembersResponse,
GetMemberByUsernameRequest,
GetMemberByUsernameResponse,
GetMemberRequest,
GetMemberResponse,
UpdateMemberRequest,
UpdateMemberResponse,
CreateMemberResponse,
CreateMemberRequest,
} from 'app/modules/proto/c2se/member_pb';
import {
SUBJECT_LIST_MEMBERS,
SUBJECT_GET_MEMBER,
SUBJECT_GET_MEMBER_BY_USERNAME,
SUBJECT_UPDATE_MEMBER,
SUBJECT_CREATE_MEMBER,
} from 'app/modules/proto/c2se/backend/member_pb';
import { Pagination } from 'app/modules/proto/protobuf/pagination_pb';
@Injectable({
providedIn: 'root',
})
export class MemberService {
/**
* Constructor
*/
constructor(private __natsService: NatsService) {}
// -----------------------------------------------------------------------------------------------------
// @ Accessors
// -----------------------------------------------------------------------------------------------------
// -----------------------------------------------------------------------------------------------------
// @ Public methods
// -----------------------------------------------------------------------------------------------------
listMembers(req?: ListMembersRequest): Promise<ListMembersResponse.Result> {
return new Promise<ListMembersResponse.Result>((resolve, reject) => {
if (!req) {
req = new ListMembersRequest();
}
if (!req.hasPagination()) {
let paging = new Pagination();
paging.setPageSize(10);
paging.setPage(0);
req.setPagination(paging);
}
this.__natsService
.request<ListMembersResponse.Result>(
SUBJECT_LIST_MEMBERS,
req.serializeBinary(),
ListMembersResponse.deserializeBinary
)
.then((result) => {
console.log('success', result, result.getMembersList());
resolve(result);
})
.catch((e: Error) => {
console.log('failed', e);
reject(e);
});
});
}
getMember(id: string): Promise<GetMemberResponse.Result> {
return new Promise<GetMemberResponse.Result>((resolve, reject) => {
let req = new GetMemberRequest();
req.setId(id);
this.__natsService
.request<GetMemberResponse.Result>(
SUBJECT_GET_MEMBER,
req.serializeBinary(),
GetMemberResponse.deserializeBinary
)
.then((result) => {
console.log('success', result, result.getMember());
resolve(result);
})
.catch((e: Error) => {
console.log('failed', e);
reject(e);
});
});
}
getMemberByUsername(): Promise<GetMemberByUsernameResponse.Result> {
return new Promise<GetMemberByUsernameResponse.Result>(
(resolve, reject) => {
let req = new GetMemberByUsernameRequest();
this.__natsService
.request<GetMemberByUsernameResponse.Result>(
SUBJECT_GET_MEMBER_BY_USERNAME,
req.serializeBinary(),
GetMemberByUsernameResponse.deserializeBinary
)
.then((result) => {
resolve(result);
})
.catch((e: Error) => {
console.log('failed', e);
reject(e);
});
}
);
}
updateMember(
id: string,
siteId: string,
memberLevelId: string,
password: string,
mobilePhoneNumber: string
): Promise<UpdateMemberResponse.Result> {
return new Promise<UpdateMemberResponse.Result>((resolve, reject) => {
let req = new UpdateMemberRequest();
req.setId(id);
if (!!siteId) {
req.setSiteId(siteId);
}
if (!!memberLevelId) {
req.setMemberLevelId(memberLevelId);
}
if (!!password) {
req.setPassword(password);
}
if (!!mobilePhoneNumber) {
req.setMobilePhoneNumber(mobilePhoneNumber);
}
this.__natsService
.request<UpdateMemberResponse.Result>(
SUBJECT_UPDATE_MEMBER,
req.serializeBinary(),
UpdateMemberResponse.deserializeBinary
)
.then((result) => {
console.log('updateMember Result: ', result);
resolve(result);
})
.catch((e: Error) => {
console.log('failed', e);
reject(e);
});
});
}
// siteId: 8429a7ab-b9de-400b-a209-28ff46e22bec
// classId: 4b014ef5-3bab-4413-aaf9-b0040a70ec77
// levelId: c56231ac-2120-4a81-a30a-5d41fafb6c57
createMember(req: CreateMemberRequest): Promise<CreateMemberResponse.Result> {
return new Promise<CreateMemberResponse.Result>((resolve, reject) => {
this.__natsService
.request<CreateMemberResponse.Result>(
SUBJECT_CREATE_MEMBER,
req.serializeBinary(),
CreateMemberResponse.deserializeBinary
)
.then((result) => {
console.log('createMember Result: ', result);
resolve(result);
})
.catch((e: Error) => {
console.log('failed', e);
reject(e);
});
});
}
}

16
src/app/modules/polyglot/member_bank_account/member_bank_account.module.ts Normal file
View File

@ -0,0 +1,16 @@
import { ModuleWithProviders, NgModule } from '@angular/core';
import { SERVICES } from './services';
@NgModule({})
export class MemberBankAccountRootModule {}
@NgModule({})
export class MemberBankAccountModule {
public static forRoot(): ModuleWithProviders<MemberBankAccountRootModule> {
return {
ngModule: MemberBankAccountRootModule,
providers: [...SERVICES],
};
}
}

5
src/app/modules/polyglot/member_bank_account/services/index.ts Normal file
View File

@ -0,0 +1,5 @@
import { Type } from '@angular/core';
import { MemberBankAccountService } from './member_bank_account.service';
export const SERVICES: Type<any>[] = [MemberBankAccountService];

158
src/app/modules/polyglot/member_bank_account/services/member_bank_account.service.ts Normal file
View File

@ -0,0 +1,158 @@
import { Injectable } from '@angular/core';
import { NatsService } from 'app/core/nats/services/nats.service';
import * as nats from 'nats.ws';
import { Error } from 'app/modules/proto/protobuf/rpc_pb';
import {
ListMemberBankAccountsRequest,
ListMemberBankAccountsResponse,
CreateMemberBankAccountRequest,
CreateMemberBankAccountResponse,
UpdateMemberBankAccountRequest,
UpdateMemberBankAccountResponse,
DeleteMemberBankAccountRequest,
DeleteMemberBankAccountResponse,
GetMemberBankAccountResponse,
GetMemberBankAccountRequest,
} from 'app/modules/proto/c2se/member_bank_account_pb';
import {
SUBJECT_LIST_MEMBER_BANK_ACCOUNTS,
SUBJECT_CREATE_MEMBER_BANK_ACCOUNT,
SUBJECT_UPDATE_MEMBER_BANK_ACCOUNT,
SUBJECT_DELETE_MEMBER_BANK_ACCOUNT,
SUBJECT_GET_MEMBER_BANK_ACCOUNT,
} from 'app/modules/proto/c2se/backend/member_bank_account_pb';
@Injectable({
providedIn: 'root',
})
export class MemberBankAccountService {
/**
* Constructor
*/
constructor(private __natsService: NatsService) {}
// -----------------------------------------------------------------------------------------------------
// @ Accessors
// -----------------------------------------------------------------------------------------------------
// -----------------------------------------------------------------------------------------------------
// @ Public methods
// -----------------------------------------------------------------------------------------------------
createMemberBankAccount(): Promise<CreateMemberBankAccountResponse.Result> {
return new Promise<CreateMemberBankAccountResponse.Result>(
(resolve, reject) => {
let req = new CreateMemberBankAccountRequest();
this.__natsService
.request<CreateMemberBankAccountResponse.Result>(
SUBJECT_CREATE_MEMBER_BANK_ACCOUNT,
req.serializeBinary(),
CreateMemberBankAccountResponse.deserializeBinary
)
.then((result) => {
console.log('success', result, result.getMemberBankAccount());
return resolve(result);
})
.catch((e: Error) => {
console.log('failed', e);
return reject(e);
});
}
);
}
listMemberBankAccounts(): Promise<ListMemberBankAccountsResponse.Result> {
return new Promise<ListMemberBankAccountsResponse.Result>(
(resolve, reject) => {
let req = new ListMemberBankAccountsRequest();
this.__natsService
.request<ListMemberBankAccountsResponse.Result>(
SUBJECT_LIST_MEMBER_BANK_ACCOUNTS,
req.serializeBinary(),
ListMemberBankAccountsResponse.deserializeBinary
)
.then((result) => {
console.log('success', result, result.getMemberBankAccountsList());
return resolve(result);
})
.catch((e: Error) => {
console.log('failed', e);
reject(e);
});
}
);
}
getMemberBankAccount(): Promise<GetMemberBankAccountResponse.Result> {
return new Promise<GetMemberBankAccountResponse.Result>(
(resolve, reject) => {
let req = new GetMemberBankAccountRequest();
this.__natsService
.request<GetMemberBankAccountResponse.Result>(
SUBJECT_GET_MEMBER_BANK_ACCOUNT,
req.serializeBinary(),
GetMemberBankAccountResponse.deserializeBinary
)
.then((result) => {
console.log('success', result, result.getMemberBankAccount());
return resolve(result);
})
.catch((e: Error) => {
console.log('failed', e);
return reject(e);
});
}
);
}
updateMemberBankAccount(): Promise<UpdateMemberBankAccountResponse.Result> {
return new Promise<UpdateMemberBankAccountResponse.Result>(
(resolve, reject) => {
let req = new UpdateMemberBankAccountRequest();
this.__natsService
.request<UpdateMemberBankAccountResponse.Result>(
SUBJECT_UPDATE_MEMBER_BANK_ACCOUNT,
req.serializeBinary(),
UpdateMemberBankAccountResponse.deserializeBinary
)
.then((result) => {
console.log('success', result, result.getMemberBankAccount());
return resolve(result);
})
.catch((e: Error) => {
console.log('failed', e);
return reject(e);
});
}
);
}
deleteMemberBankAccount(): Promise<DeleteMemberBankAccountResponse.Result> {
return new Promise<DeleteMemberBankAccountResponse.Result>(
(resolve, reject) => {
let req = new DeleteMemberBankAccountRequest();
this.__natsService
.request<DeleteMemberBankAccountResponse.Result>(
SUBJECT_DELETE_MEMBER_BANK_ACCOUNT,
req.serializeBinary(),
DeleteMemberBankAccountResponse.deserializeBinary
)
.then((result) => {
console.log('success', result);
return resolve(result);
})
.catch((e: Error) => {
console.log('failed', e);
return reject(e);
});
}
);
}
}

16
src/app/modules/polyglot/member_bank_deposit/member_bank_deposit.module.ts Normal file
View File

@ -0,0 +1,16 @@
import { ModuleWithProviders, NgModule } from '@angular/core';
import { SERVICES } from './services';
@NgModule({})
export class MemberBankDepositRootModule {}
@NgModule({})
export class MemberBankDepositModule {
public static forRoot(): ModuleWithProviders<MemberBankDepositRootModule> {
return {
ngModule: MemberBankDepositRootModule,
providers: [...SERVICES],
};
}
}

5
src/app/modules/polyglot/member_bank_deposit/services/index.ts Normal file
View File

@ -0,0 +1,5 @@
import { Type } from '@angular/core';
import { MemberBankDepositService } from './member_bank_deposit.service';
export const SERVICES: Type<any>[] = [MemberBankDepositService];

184
src/app/modules/polyglot/member_bank_deposit/services/member_bank_deposit.service.ts Normal file
View File

@ -0,0 +1,184 @@
import { Injectable } from '@angular/core';
import { NatsService } from 'app/core/nats/services/nats.service';
import * as nats from 'nats.ws';
import { Error } from 'app/modules/proto/protobuf/rpc_pb';
import {
ListMemberBankDepositsRequest,
ListMemberBankDepositsResponse,
CreateMemberBankDepositRequest,
CreateMemberBankDepositResponse,
UpdateMemberBankDepositRequest,
UpdateMemberBankDepositResponse,
DeleteMemberBankDepositRequest,
DeleteMemberBankDepositResponse,
GetMemberBankDepositResponse,
GetMemberBankDepositRequest,
UpdateMemberBankDepositForStateResponse,
UpdateMemberBankDepositForStateRequest,
} from 'app/modules/proto/c2se/member_bank_deposit_pb';
import {
SUBJECT_LIST_MEMBER_BANK_DEPOSITS,
SUBJECT_CREATE_MEMBER_BANK_DEPOSIT,
SUBJECT_UPDATE_MEMBER_BANK_DEPOSIT,
SUBJECT_DELETE_MEMBER_BANK_DEPOSIT,
SUBJECT_GET_MEMBER_BANK_DEPOSIT,
SUBJECT_UPDATE_MEMBER_BANK_DEPOSIT_FOR_STATE,
} from 'app/modules/proto/c2se/backend/member_bank_deposit_pb';
@Injectable({
providedIn: 'root',
})
export class MemberBankDepositService {
/**
* Constructor
*/
constructor(private __natsService: NatsService) {}
// -----------------------------------------------------------------------------------------------------
// @ Accessors
// -----------------------------------------------------------------------------------------------------
// -----------------------------------------------------------------------------------------------------
// @ Public methods
// -----------------------------------------------------------------------------------------------------
createMemberBankDeposit(): Promise<CreateMemberBankDepositResponse.Result> {
return new Promise<CreateMemberBankDepositResponse.Result>(
(resolve, reject) => {
let req = new CreateMemberBankDepositRequest();
this.__natsService
.request<CreateMemberBankDepositResponse.Result>(
SUBJECT_CREATE_MEMBER_BANK_DEPOSIT,
req.serializeBinary(),
CreateMemberBankDepositResponse.deserializeBinary
)
.then((result) => {
console.log('success', result, result.getMemberBankDeposit());
return resolve(result);
})
.catch((e: Error) => {
console.log('failed', e);
return reject(e);
});
}
);
}
listMemberBankDeposits(): Promise<ListMemberBankDepositsResponse.Result> {
return new Promise<ListMemberBankDepositsResponse.Result>(
(resolve, reject) => {
let req = new ListMemberBankDepositsRequest();
this.__natsService
.request<ListMemberBankDepositsResponse.Result>(
SUBJECT_LIST_MEMBER_BANK_DEPOSITS,
req.serializeBinary(),
ListMemberBankDepositsResponse.deserializeBinary
)
.then((result) => {
console.log('success', result, result.getMemberBankDepositsList());
return resolve(result);
})
.catch((e: Error) => {
console.log('failed', e);
reject(e);
});
}
);
}
getMemberBankDeposit(): Promise<GetMemberBankDepositResponse.Result> {
return new Promise<GetMemberBankDepositResponse.Result>(
(resolve, reject) => {
let req = new GetMemberBankDepositRequest();
this.__natsService
.request<GetMemberBankDepositResponse.Result>(
SUBJECT_GET_MEMBER_BANK_DEPOSIT,
req.serializeBinary(),
GetMemberBankDepositResponse.deserializeBinary
)
.then((result) => {
console.log('success', result, result.getMemberBankDeposit());
return resolve(result);
})
.catch((e: Error) => {
console.log('failed', e);
return reject(e);
});
}
);
}
updateMemberBankDeposit(): Promise<UpdateMemberBankDepositResponse.Result> {
return new Promise<UpdateMemberBankDepositResponse.Result>(
(resolve, reject) => {
let req = new UpdateMemberBankDepositRequest();
this.__natsService
.request<UpdateMemberBankDepositResponse.Result>(
SUBJECT_UPDATE_MEMBER_BANK_DEPOSIT,
req.serializeBinary(),
UpdateMemberBankDepositResponse.deserializeBinary
)
.then((result) => {
console.log('success', result, result.getMemberBankDeposit());
return resolve(result);
})
.catch((e: Error) => {
console.log('failed', e);
return reject(e);
});
}
);
}
updateMemberBankDepositForState(): Promise<UpdateMemberBankDepositForStateResponse.Result> {
return new Promise<UpdateMemberBankDepositForStateResponse.Result>(
(resolve, reject) => {
let req = new UpdateMemberBankDepositForStateRequest();
this.__natsService
.request<UpdateMemberBankDepositForStateResponse.Result>(
SUBJECT_UPDATE_MEMBER_BANK_DEPOSIT_FOR_STATE,
req.serializeBinary(),
UpdateMemberBankDepositForStateResponse.deserializeBinary
)
.then((result) => {
console.log('success', result, result.getMemberBankDeposit());
return resolve(result);
})
.catch((e: Error) => {
console.log('failed', e);
return reject(e);
});
}
);
}
deleteMemberBankDeposit(): Promise<DeleteMemberBankDepositResponse.Result> {
return new Promise<DeleteMemberBankDepositResponse.Result>(
(resolve, reject) => {
let req = new DeleteMemberBankDepositRequest();
this.__natsService
.request<DeleteMemberBankDepositResponse.Result>(
SUBJECT_DELETE_MEMBER_BANK_DEPOSIT,
req.serializeBinary(),
DeleteMemberBankDepositResponse.deserializeBinary
)
.then((result) => {
console.log('success', result);
return resolve(result);
})
.catch((e: Error) => {
console.log('failed', e);
return reject(e);
});
}
);
}
}

16
src/app/modules/polyglot/member_bank_withdraw/member_bank_withdraw.module.ts Normal file
View File

@ -0,0 +1,16 @@
import { ModuleWithProviders, NgModule } from '@angular/core';
import { SERVICES } from './services';
@NgModule({})
export class MemberBankWithdrawRootModule {}
@NgModule({})
export class MemberBankWithdrawModule {
public static forRoot(): ModuleWithProviders<MemberBankWithdrawRootModule> {
return {
ngModule: MemberBankWithdrawRootModule,
providers: [...SERVICES],
};
}
}

5
src/app/modules/polyglot/member_bank_withdraw/services/index.ts Normal file
View File

@ -0,0 +1,5 @@
import { Type } from '@angular/core';
import { MemberBankWithdrawService } from './member_bank_withdraw.service';
export const SERVICES: Type<any>[] = [MemberBankWithdrawService];

184
src/app/modules/polyglot/member_bank_withdraw/services/member_bank_withdraw.service.ts Normal file
View File

@ -0,0 +1,184 @@
import { Injectable } from '@angular/core';
import { NatsService } from 'app/core/nats/services/nats.service';
import * as nats from 'nats.ws';
import { Error } from 'app/modules/proto/protobuf/rpc_pb';
import {
ListMemberBankWithdrawsRequest,
ListMemberBankWithdrawsResponse,
CreateMemberBankWithdrawRequest,
CreateMemberBankWithdrawResponse,
UpdateMemberBankWithdrawRequest,
UpdateMemberBankWithdrawResponse,
DeleteMemberBankWithdrawRequest,
DeleteMemberBankWithdrawResponse,
GetMemberBankWithdrawResponse,
GetMemberBankWithdrawRequest,
UpdateMemberBankWithdrawForStateResponse,
UpdateMemberBankWithdrawForStateRequest,
} from 'app/modules/proto/c2se/member_bank_withdraw_pb';
import {
SUBJECT_LIST_MEMBER_BANK_WITHDRAWS,
SUBJECT_CREATE_MEMBER_BANK_WITHDRAW,
SUBJECT_UPDATE_MEMBER_BANK_WITHDRAW,
SUBJECT_DELETE_MEMBER_BANK_WITHDRAW,
SUBJECT_GET_MEMBER_BANK_WITHDRAW,
SUBJECT_UPDATE_MEMBER_BANK_WITHDRAW_FOR_STATE,
} from 'app/modules/proto/c2se/backend/member_bank_withdraw_pb';
@Injectable({
providedIn: 'root',
})
export class MemberBankWithdrawService {
/**
* Constructor
*/
constructor(private __natsService: NatsService) {}
// -----------------------------------------------------------------------------------------------------
// @ Accessors
// -----------------------------------------------------------------------------------------------------
// -----------------------------------------------------------------------------------------------------
// @ Public methods
// -----------------------------------------------------------------------------------------------------
createMemberBankWithdraw(): Promise<CreateMemberBankWithdrawResponse.Result> {
return new Promise<CreateMemberBankWithdrawResponse.Result>(
(resolve, reject) => {
let req = new CreateMemberBankWithdrawRequest();
this.__natsService
.request<CreateMemberBankWithdrawResponse.Result>(
SUBJECT_CREATE_MEMBER_BANK_WITHDRAW,
req.serializeBinary(),
CreateMemberBankWithdrawResponse.deserializeBinary
)
.then((result) => {
console.log('success', result, result.getMemberBankWithdraw());
return resolve(result);
})
.catch((e: Error) => {
console.log('failed', e);
return reject(e);
});
}
);
}
listMemberBankWithdraws(): Promise<ListMemberBankWithdrawsResponse.Result> {
return new Promise<ListMemberBankWithdrawsResponse.Result>(
(resolve, reject) => {
let req = new ListMemberBankWithdrawsRequest();
this.__natsService
.request<ListMemberBankWithdrawsResponse.Result>(
SUBJECT_LIST_MEMBER_BANK_WITHDRAWS,
req.serializeBinary(),
ListMemberBankWithdrawsResponse.deserializeBinary
)
.then((result) => {
console.log('success', result, result.getMemberBankWithdrawsList());
return resolve(result);
})
.catch((e: Error) => {
console.log('failed', e);
reject(e);
});
}
);
}
getMemberBankWithdraw(): Promise<GetMemberBankWithdrawResponse.Result> {
return new Promise<GetMemberBankWithdrawResponse.Result>(
(resolve, reject) => {
let req = new GetMemberBankWithdrawRequest();
this.__natsService
.request<GetMemberBankWithdrawResponse.Result>(
SUBJECT_GET_MEMBER_BANK_WITHDRAW,
req.serializeBinary(),
GetMemberBankWithdrawResponse.deserializeBinary
)
.then((result) => {
console.log('success', result, result.getMemberBankWithdraw());
return resolve(result);
})
.catch((e: Error) => {
console.log('failed', e);
return reject(e);
});
}
);
}
updateMemberBankWithdraw(): Promise<UpdateMemberBankWithdrawResponse.Result> {
return new Promise<UpdateMemberBankWithdrawResponse.Result>(
(resolve, reject) => {
let req = new UpdateMemberBankWithdrawRequest();
this.__natsService
.request<UpdateMemberBankWithdrawResponse.Result>(
SUBJECT_UPDATE_MEMBER_BANK_WITHDRAW,
req.serializeBinary(),
UpdateMemberBankWithdrawResponse.deserializeBinary
)
.then((result) => {
console.log('success', result, result.getMemberBankWithdraw());
return resolve(result);
})
.catch((e: Error) => {
console.log('failed', e);
return reject(e);
});
}
);
}
updateMemberBankWithdrawForState(): Promise<UpdateMemberBankWithdrawForStateResponse.Result> {
return new Promise<UpdateMemberBankWithdrawForStateResponse.Result>(
(resolve, reject) => {
let req = new UpdateMemberBankWithdrawForStateRequest();
this.__natsService
.request<UpdateMemberBankWithdrawForStateResponse.Result>(
SUBJECT_UPDATE_MEMBER_BANK_WITHDRAW_FOR_STATE,
req.serializeBinary(),
UpdateMemberBankWithdrawForStateResponse.deserializeBinary
)
.then((result) => {
console.log('success', result, result.getMemberBankWithdraw());
return resolve(result);
})
.catch((e: Error) => {
console.log('failed', e);
return reject(e);
});
}
);
}
deleteMemberBankWithdraw(): Promise<DeleteMemberBankWithdrawResponse.Result> {
return new Promise<DeleteMemberBankWithdrawResponse.Result>(
(resolve, reject) => {
let req = new DeleteMemberBankWithdrawRequest();
this.__natsService
.request<DeleteMemberBankWithdrawResponse.Result>(
SUBJECT_DELETE_MEMBER_BANK_WITHDRAW,
req.serializeBinary(),
DeleteMemberBankWithdrawResponse.deserializeBinary
)
.then((result) => {
console.log('success', result);
return resolve(result);
})
.catch((e: Error) => {
console.log('failed', e);
return reject(e);
});
}
);
}
}

16
src/app/modules/polyglot/member_class/member_class.module.ts Normal file
View File

@ -0,0 +1,16 @@
import { ModuleWithProviders, NgModule } from '@angular/core';
import { SERVICES } from './services';
@NgModule({})
export class MemberClassRootModule {}
@NgModule({})
export class MemberClassModule {
public static forRoot(): ModuleWithProviders<MemberClassRootModule> {
return {
ngModule: MemberClassRootModule,
providers: [...SERVICES],
};
}
}

5
src/app/modules/polyglot/member_class/services/index.ts Normal file
View File

@ -0,0 +1,5 @@
import { Type } from '@angular/core';
import { MemberClassService } from './member_class.service';
export const SERVICES: Type<any>[] = [MemberClassService];

148
src/app/modules/polyglot/member_class/services/member_class.service.ts Normal file
View File

@ -0,0 +1,148 @@
import { Injectable } from '@angular/core';
import { NatsService } from 'app/core/nats/services/nats.service';
import * as nats from 'nats.ws';
import { Error } from 'app/modules/proto/protobuf/rpc_pb';
import {
ListMemberClassesRequest,
ListMemberClassesResponse,
CreateMemberClassRequest,
CreateMemberClassResponse,
UpdateMemberClassRequest,
UpdateMemberClassResponse,
DeleteMemberClassRequest,
DeleteMemberClassResponse,
GetMemberClassResponse,
GetMemberClassRequest,
} from 'app/modules/proto/c2se/member_class_pb';
import {
SUBJECT_LIST_MEMBER_CLASSES,
SUBJECT_CREATE_MEMBER_CLASS,
SUBJECT_UPDATE_MEMBER_CLASS,
SUBJECT_DELETE_MEMBER_CLASS,
SUBJECT_GET_MEMBER_CLASS,
} from 'app/modules/proto/c2se/backend/member_class_pb';
@Injectable({
providedIn: 'root',
})
export class MemberClassService {
/**
* Constructor
*/
constructor(private __natsService: NatsService) {}
// -----------------------------------------------------------------------------------------------------
// @ Accessors
// -----------------------------------------------------------------------------------------------------
// -----------------------------------------------------------------------------------------------------
// @ Public methods
// -----------------------------------------------------------------------------------------------------
createMemberClass(): Promise<CreateMemberClassResponse.Result> {
return new Promise<CreateMemberClassResponse.Result>((resolve, reject) => {
let req = new CreateMemberClassRequest();
this.__natsService
.request<CreateMemberClassResponse.Result>(
SUBJECT_CREATE_MEMBER_CLASS,
req.serializeBinary(),
CreateMemberClassResponse.deserializeBinary
)
.then((result) => {
console.log('success', result, result.getMemberClass());
return resolve(result);
})
.catch((e: Error) => {
console.log('failed', e);
return reject(e);
});
});
}
listMemberClasss(): Promise<ListMemberClassesResponse.Result> {
return new Promise<ListMemberClassesResponse.Result>((resolve, reject) => {
let req = new ListMemberClassesRequest();
this.__natsService
.request<ListMemberClassesResponse.Result>(
SUBJECT_LIST_MEMBER_CLASSES,
req.serializeBinary(),
ListMemberClassesResponse.deserializeBinary
)
.then((result) => {
console.log('success', result, result.getMemberClassesList());
return resolve(result);
})
.catch((e: Error) => {
console.log('failed', e);
reject(e);
});
});
}
getMemberClass(): Promise<GetMemberClassResponse.Result> {
return new Promise<GetMemberClassResponse.Result>((resolve, reject) => {
let req = new GetMemberClassRequest();
this.__natsService
.request<GetMemberClassResponse.Result>(
SUBJECT_GET_MEMBER_CLASS,
req.serializeBinary(),
GetMemberClassResponse.deserializeBinary
)
.then((result) => {
console.log('success', result, result.getMemberClass());
return resolve(result);
})
.catch((e: Error) => {
console.log('failed', e);
return reject(e);
});
});
}
updateMemberClass(): Promise<UpdateMemberClassResponse.Result> {
return new Promise<UpdateMemberClassResponse.Result>((resolve, reject) => {
let req = new UpdateMemberClassRequest();
this.__natsService
.request<UpdateMemberClassResponse.Result>(
SUBJECT_UPDATE_MEMBER_CLASS,
req.serializeBinary(),
UpdateMemberClassResponse.deserializeBinary
)
.then((result) => {
console.log('success', result, result.getMemberClass());
return resolve(result);
})
.catch((e: Error) => {
console.log('failed', e);
return reject(e);
});
});
}
deleteMemberClass(): Promise<DeleteMemberClassResponse.Result> {
return new Promise<DeleteMemberClassResponse.Result>((resolve, reject) => {
let req = new DeleteMemberClassRequest();
this.__natsService
.request<DeleteMemberClassResponse.Result>(
SUBJECT_DELETE_MEMBER_CLASS,
req.serializeBinary(),
DeleteMemberClassResponse.deserializeBinary
)
.then((result) => {
console.log('success', result);
return resolve(result);
})
.catch((e: Error) => {
console.log('failed', e);
return reject(e);
});
});
}
}

16
src/app/modules/polyglot/member_level/member_level.module.ts Normal file
View File

@ -0,0 +1,16 @@
import { ModuleWithProviders, NgModule } from '@angular/core';
import { SERVICES } from './services';
@NgModule({})
export class MemberLevelRootModule {}
@NgModule({})
export class MemberLevelModule {
public static forRoot(): ModuleWithProviders<MemberLevelRootModule> {
return {
ngModule: MemberLevelRootModule,
providers: [...SERVICES],
};
}
}

5
src/app/modules/polyglot/member_level/services/index.ts Normal file
View File

@ -0,0 +1,5 @@
import { Type } from '@angular/core';
import { MemberLevelService } from './member_level.service';
export const SERVICES: Type<any>[] = [MemberLevelService];

148
src/app/modules/polyglot/member_level/services/member_level.service.ts Normal file
View File

@ -0,0 +1,148 @@
import { Injectable } from '@angular/core';
import { NatsService } from 'app/core/nats/services/nats.service';
import * as nats from 'nats.ws';
import { Error } from 'app/modules/proto/protobuf/rpc_pb';
import {
ListMemberLevelsRequest,
ListMemberLevelsResponse,
CreateMemberLevelRequest,
CreateMemberLevelResponse,
UpdateMemberLevelRequest,
UpdateMemberLevelResponse,
DeleteMemberLevelRequest,
DeleteMemberLevelResponse,
GetMemberLevelResponse,
GetMemberLevelRequest,
} from 'app/modules/proto/c2se/member_level_pb';
import {
SUBJECT_LIST_MEMBER_LEVELS,
SUBJECT_CREATE_MEMBER_LEVEL,
SUBJECT_UPDATE_MEMBER_LEVEL,
SUBJECT_DELETE_MEMBER_LEVEL,
SUBJECT_GET_MEMBER_LEVEL,
} from 'app/modules/proto/c2se/backend/member_level_pb';
@Injectable({
providedIn: 'root',
})
export class MemberLevelService {
/**
* Constructor
*/
constructor(private __natsService: NatsService) {}
// -----------------------------------------------------------------------------------------------------
// @ Accessors
// -----------------------------------------------------------------------------------------------------
// -----------------------------------------------------------------------------------------------------
// @ Public methods
// -----------------------------------------------------------------------------------------------------
createMemberLevel(): Promise<CreateMemberLevelResponse.Result> {
return new Promise<CreateMemberLevelResponse.Result>((resolve, reject) => {
let req = new CreateMemberLevelRequest();
this.__natsService
.request<CreateMemberLevelResponse.Result>(
SUBJECT_CREATE_MEMBER_LEVEL,
req.serializeBinary(),
CreateMemberLevelResponse.deserializeBinary
)
.then((result) => {
console.log('success', result, result.getMemberLevel());
return resolve(result);
})
.catch((e: Error) => {
console.log('failed', e);
return reject(e);
});
});
}
listMemberLevels(): Promise<ListMemberLevelsResponse.Result> {
return new Promise<ListMemberLevelsResponse.Result>((resolve, reject) => {
let req = new ListMemberLevelsRequest();
this.__natsService
.request<ListMemberLevelsResponse.Result>(
SUBJECT_LIST_MEMBER_LEVELS,
req.serializeBinary(),
ListMemberLevelsResponse.deserializeBinary
)
.then((result) => {
console.log('success', result, result.getMemberLevelsList());
return resolve(result);
})
.catch((e: Error) => {
console.log('failed', e);
reject(e);
});
});
}
getMemberLevel(): Promise<GetMemberLevelResponse.Result> {
return new Promise<GetMemberLevelResponse.Result>((resolve, reject) => {
let req = new GetMemberLevelRequest();
this.__natsService
.request<GetMemberLevelResponse.Result>(
SUBJECT_GET_MEMBER_LEVEL,
req.serializeBinary(),
GetMemberLevelResponse.deserializeBinary
)
.then((result) => {
console.log('success', result, result.getMemberLevel());
return resolve(result);
})
.catch((e: Error) => {
console.log('failed', e);
return reject(e);
});
});
}
updateMemberLevel(): Promise<UpdateMemberLevelResponse.Result> {
return new Promise<UpdateMemberLevelResponse.Result>((resolve, reject) => {
let req = new UpdateMemberLevelRequest();
this.__natsService
.request<UpdateMemberLevelResponse.Result>(
SUBJECT_UPDATE_MEMBER_LEVEL,
req.serializeBinary(),
UpdateMemberLevelResponse.deserializeBinary
)
.then((result) => {
console.log('success', result, result.getMemberLevel());
return resolve(result);
})
.catch((e: Error) => {
console.log('failed', e);
return reject(e);
});
});
}
deleteMemberLevel(): Promise<DeleteMemberLevelResponse.Result> {
return new Promise<DeleteMemberLevelResponse.Result>((resolve, reject) => {
let req = new DeleteMemberLevelRequest();
this.__natsService
.request<DeleteMemberLevelResponse.Result>(
SUBJECT_DELETE_MEMBER_LEVEL,
req.serializeBinary(),
DeleteMemberLevelResponse.deserializeBinary
)
.then((result) => {
console.log('success', result);
return resolve(result);
})
.catch((e: Error) => {
console.log('failed', e);
return reject(e);
});
});
}
}

5
src/app/modules/polyglot/site/services/index.ts Normal file
View File

@ -0,0 +1,5 @@
import { Type } from '@angular/core';
import { SiteService } from './site.service';
export const SERVICES: Type<any>[] = [SiteService];

82
src/app/modules/polyglot/site/services/site.service.ts Normal file
View File

@ -0,0 +1,82 @@
import { Injectable } from '@angular/core';
import { NatsService } from 'app/core/nats/services/nats.service';
import * as nats from 'nats.ws';
import { Error } from 'app/modules/proto/protobuf/rpc_pb';
import {
ListSitesRequest,
ListSitesResponse,
CreateSiteRequest,
CreateSiteResponse,
UpdateSiteRequest,
UpdateSiteResponse,
DeleteSiteRequest,
DeleteSiteResponse,
} from 'app/modules/proto/c2se/site_pb';
import {
SUBJECT_LIST_SITES,
SUBJECT_CREATE_SITE,
SUBJECT_UPDATE_SITE,
SUBJECT_DELETE_SITE,
} from 'app/modules/proto/c2se/backend/site_pb';
@Injectable({
providedIn: 'root',
})
export class SiteService {
/**
* Constructor
*/
constructor(private __natsService: NatsService) {}
// -----------------------------------------------------------------------------------------------------
// @ Accessors
// -----------------------------------------------------------------------------------------------------
// -----------------------------------------------------------------------------------------------------
// @ Public methods
// -----------------------------------------------------------------------------------------------------
listSites(): Promise<ListSitesResponse.Result> {
return new Promise<ListSitesResponse.Result>((resolve, reject) => {
let req = new ListSitesRequest();
this.__natsService
.request<ListSitesResponse.Result>(
SUBJECT_LIST_SITES,
req.serializeBinary(),
ListSitesResponse.deserializeBinary
)
.then((result) => {
console.log('success', result, result.getSitesList());
return resolve(result);
})
.catch((e: Error) => {
console.log('failed', e);
reject(e);
});
});
}
createSite(): Promise<CreateSiteResponse.Result> {
return new Promise<CreateSiteResponse.Result>((resolve, reject) => {
let req = new CreateSiteRequest();
this.__natsService
.request<CreateSiteResponse.Result>(
SUBJECT_CREATE_SITE,
req.serializeBinary(),
CreateSiteResponse.deserializeBinary
)
.then((result) => {
console.log('success', result, result.getSite());
return resolve(result);
})
.catch((e: Error) => {
console.log('failed', e);
return reject(e);
});
});
}
}

16
src/app/modules/polyglot/site/site.module.ts Normal file
View File

@ -0,0 +1,16 @@
import { ModuleWithProviders, NgModule } from '@angular/core';
import { SERVICES } from './services';
@NgModule({})
export class SiteRootModule {}
@NgModule({})
export class SiteModule {
public static forRoot(): ModuleWithProviders<SiteRootModule> {
return {
ngModule: SiteRootModule,
providers: [...SERVICES],
};
}
}

188
src/app/modules/proto/c2se/api/vendor_pb.d.ts vendored Normal file
View File

@ -0,0 +1,188 @@
// package: bet.beteran.c2se.api.vendor
// file: c2se/api/vendor.proto
import * as jspb from 'google-protobuf';
import * as protobuf_rpc_pb from '../../protobuf/rpc_pb';
import * as protobuf_pagination_pb from '../../protobuf/pagination_pb';
import * as models_core_network_pb from '../../models/core/network_pb';
import * as models_api_vendor_pb from '../../models/api/vendor_pb';
export class ListVendorsRequest extends jspb.Message {
hasPagination(): boolean;
clearPagination(): void;
getPagination(): protobuf_pagination_pb.Pagination | undefined;
setPagination(value?: protobuf_pagination_pb.Pagination): void;
clearSortsList(): void;
getSortsList(): Array<protobuf_pagination_pb.Sort>;
setSortsList(value: Array<protobuf_pagination_pb.Sort>): void;
addSorts(
value?: protobuf_pagination_pb.Sort,
index?: number
): protobuf_pagination_pb.Sort;
hasSearch(): boolean;
clearSearch(): void;
getSearch(): ListVendorsRequest.Search | undefined;
setSearch(value?: ListVendorsRequest.Search): void;
serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): ListVendorsRequest.AsObject;
static toObject(
includeInstance: boolean,
msg: ListVendorsRequest
): ListVendorsRequest.AsObject;
static extensions: { [key: number]: jspb.ExtensionFieldInfo<jspb.Message> };
static extensionsBinary: {
[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>;
};
static serializeBinaryToWriter(
message: ListVendorsRequest,
writer: jspb.BinaryWriter
): void;
static deserializeBinary(bytes: Uint8Array): ListVendorsRequest;
static deserializeBinaryFromReader(
message: ListVendorsRequest,
reader: jspb.BinaryReader
): ListVendorsRequest;
}
export namespace ListVendorsRequest {
export type AsObject = {
pagination?: protobuf_pagination_pb.Pagination.AsObject;
sortsList: Array<protobuf_pagination_pb.Sort.AsObject>;
search?: ListVendorsRequest.Search.AsObject;
};
export class Search extends jspb.Message {
hasCompanyId(): boolean;
clearCompanyId(): void;
getCompanyId(): number;
setCompanyId(value: number): void;
hasVendorId(): boolean;
clearVendorId(): void;
getVendorId(): number;
setVendorId(value: number): void;
hasKeyLike(): boolean;
clearKeyLike(): void;
getKeyLike(): string;
setKeyLike(value: string): void;
hasNameLike(): boolean;
clearNameLike(): void;
getNameLike(): string;
setNameLike(value: string): void;
hasCategoryLike(): boolean;
clearCategoryLike(): void;
getCategoryLike(): string;
setCategoryLike(value: string): void;
hasIsEnable(): boolean;
clearIsEnable(): void;
getIsEnable(): string;
setIsEnable(value: string): void;
serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): Search.AsObject;
static toObject(includeInstance: boolean, msg: Search): Search.AsObject;
static extensions: { [key: number]: jspb.ExtensionFieldInfo<jspb.Message> };
static extensionsBinary: {
[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>;
};
static serializeBinaryToWriter(
message: Search,
writer: jspb.BinaryWriter
): void;
static deserializeBinary(bytes: Uint8Array): Search;
static deserializeBinaryFromReader(
message: Search,
reader: jspb.BinaryReader
): Search;
}
export namespace Search {
export type AsObject = {
companyId: number;
vendorId: number;
keyLike: string;
nameLike: string;
categoryLike: string;
isEnable: string;
};
}
}
export class ListVendorsResponse extends jspb.Message {
hasError(): boolean;
clearError(): void;
getError(): protobuf_rpc_pb.Error | undefined;
setError(value?: protobuf_rpc_pb.Error): void;
hasResult(): boolean;
clearResult(): void;
getResult(): ListVendorsResponse.Result | undefined;
setResult(value?: ListVendorsResponse.Result): void;
serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): ListVendorsResponse.AsObject;
static toObject(
includeInstance: boolean,
msg: ListVendorsResponse
): ListVendorsResponse.AsObject;
static extensions: { [key: number]: jspb.ExtensionFieldInfo<jspb.Message> };
static extensionsBinary: {
[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>;
};
static serializeBinaryToWriter(
message: ListVendorsResponse,
writer: jspb.BinaryWriter
): void;
static deserializeBinary(bytes: Uint8Array): ListVendorsResponse;
static deserializeBinaryFromReader(
message: ListVendorsResponse,
reader: jspb.BinaryReader
): ListVendorsResponse;
}
export namespace ListVendorsResponse {
export type AsObject = {
error?: protobuf_rpc_pb.Error.AsObject;
result?: ListVendorsResponse.Result.AsObject;
};
export class Result extends jspb.Message {
clearVendorsList(): void;
getVendorsList(): Array<models_api_vendor_pb.Vendor>;
setVendorsList(value: Array<models_api_vendor_pb.Vendor>): void;
addVendors(
value?: models_api_vendor_pb.Vendor,
index?: number
): models_api_vendor_pb.Vendor;
serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): Result.AsObject;
static toObject(includeInstance: boolean, msg: Result): Result.AsObject;
static extensions: { [key: number]: jspb.ExtensionFieldInfo<jspb.Message> };
static extensionsBinary: {
[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>;
};
static serializeBinaryToWriter(
message: Result,
writer: jspb.BinaryWriter
): void;
static deserializeBinary(bytes: Uint8Array): Result;
static deserializeBinaryFromReader(
message: Result,
reader: jspb.BinaryReader
): Result;
}
export namespace Result {
export type AsObject = {
vendorsList: Array<models_api_vendor_pb.Vendor.AsObject>;
};
}
}

1271
src/app/modules/proto/c2se/api/vendor_pb.js Normal file
View File

File diff suppressed because it is too large Load Diff

6
src/app/modules/proto/c2se/backend/api/vendor_pb.d.ts vendored Normal file
View File

@ -0,0 +1,6 @@
// package: bet.beteran.c2se.backend.api.vendor
// file: c2se/backend/api/vendor.proto
import * as jspb from 'google-protobuf';
export const SUBJECT_LIST_VENDORS: string;

27
src/app/modules/proto/c2se/backend/api/vendor_pb.js Normal file
View File

@ -0,0 +1,27 @@
// source: c2se/backend/api/vendor.proto
/**
* @fileoverview
* @enhanceable
* @suppress {missingRequire} reports error on implicit type usages.
* @suppress {messageConventions} JS Compiler reports an error if a variable or
* field starts with 'MSG_' and isn't a translatable message.
* @public
*/
// GENERATED CODE -- DO NOT EDIT!
/* eslint-disable */
// @ts-nocheck
var jspb = require("google-protobuf");
var goog = jspb;
var global = function () {
return this || window || global || self || Function("return this")();
}.call(null);
goog.exportSymbol("proto.bet.beteran.c2se.backend.api.vendor", null, global);
proto.bet.beteran.c2se.backend.api.vendor = {};
proto.bet.beteran.c2se.backend.api.vendor.SUBJECT_LIST_VENDORS =
"bet.beteran.c2se.backend.api.vendor.ListVendors";
goog.object.extend(exports, proto.bet.beteran.c2se.backend.api.vendor);

10
src/app/modules/proto/c2se/backend/bank_pb.d.ts vendored Normal file
View File

@ -0,0 +1,10 @@
// package: bet.beteran.c2se.backend.bank
// file: c2se/backend/bank.proto
import * as jspb from 'google-protobuf';
export const SUBJECT_CREATE_BANK: string;
export const SUBJECT_LIST_BANKS: string;
export const SUBJECT_GET_BANK: string;
export const SUBJECT_UPDATE_BANK: string;
export const SUBJECT_DELETE_BANK: string;

35
src/app/modules/proto/c2se/backend/bank_pb.js Normal file
View File

@ -0,0 +1,35 @@
// source: c2se/backend/bank.proto
/**
* @fileoverview
* @enhanceable
* @suppress {missingRequire} reports error on implicit type usages.
* @suppress {messageConventions} JS Compiler reports an error if a variable or
* field starts with 'MSG_' and isn't a translatable message.
* @public
*/
// GENERATED CODE -- DO NOT EDIT!
/* eslint-disable */
// @ts-nocheck
var jspb = require("google-protobuf");
var goog = jspb;
var global = function () {
return this || window || global || self || Function("return this")();
}.call(null);
goog.exportSymbol("proto.bet.beteran.c2se.backend.bank", null, global);
proto.bet.beteran.c2se.backend.bank = {};
proto.bet.beteran.c2se.backend.bank.SUBJECT_CREATE_BANK =
"bet.beteran.c2se.backend.bank.CreateBank";
proto.bet.beteran.c2se.backend.bank.SUBJECT_LIST_BANKS =
"bet.beteran.c2se.backend.bank.ListBanks";
proto.bet.beteran.c2se.backend.bank.SUBJECT_GET_BANK =
"bet.beteran.c2se.backend.bank.GetBank";
proto.bet.beteran.c2se.backend.bank.SUBJECT_UPDATE_BANK =
"bet.beteran.c2se.backend.bank.UpdateBank";
proto.bet.beteran.c2se.backend.bank.SUBJECT_DELETE_BANK =
"bet.beteran.c2se.backend.bank.DeleteBank";
goog.object.extend(exports, proto.bet.beteran.c2se.backend.bank);

9
src/app/modules/proto/c2se/backend/identity_pb.d.ts vendored Normal file
View File

@ -0,0 +1,9 @@
// package: bet.beteran.c2se.backend.identity
// file: c2se/backend/identity.proto
import * as jspb from 'google-protobuf';
export const SUBJECT_CHECK_USERNAME_FOR_DUPLICATION: string;
export const SUBJECT_CHECK_NICKNAME_FOR_DUPLICATION: string;
export const SUBJECT_CAPTCHA: string;
export const SUBJECT_SIGNIN: string;

33
src/app/modules/proto/c2se/backend/identity_pb.js Normal file
View File

@ -0,0 +1,33 @@
// source: c2se/backend/identity.proto
/**
* @fileoverview
* @enhanceable
* @suppress {missingRequire} reports error on implicit type usages.
* @suppress {messageConventions} JS Compiler reports an error if a variable or
* field starts with 'MSG_' and isn't a translatable message.
* @public
*/
// GENERATED CODE -- DO NOT EDIT!
/* eslint-disable */
// @ts-nocheck
var jspb = require("google-protobuf");
var goog = jspb;
var global = function () {
return this || window || global || self || Function("return this")();
}.call(null);
goog.exportSymbol("proto.bet.beteran.c2se.backend.identity", null, global);
proto.bet.beteran.c2se.backend.identity = {};
proto.bet.beteran.c2se.backend.identity.SUBJECT_CHECK_USERNAME_FOR_DUPLICATION =
"bet.beteran.c2se.backend.identity.CheckUsernameForDuplication";
proto.bet.beteran.c2se.backend.identity.SUBJECT_CHECK_NICKNAME_FOR_DUPLICATION =
"bet.beteran.c2se.backend.identity.CheckNicknameForDuplication";
proto.bet.beteran.c2se.backend.identity.SUBJECT_CAPTCHA =
"bet.beteran.c2se.backend.identity.Captcha";
proto.bet.beteran.c2se.backend.identity.SUBJECT_SIGNIN =
"bet.beteran.c2se.backend.identity.Signin";
goog.object.extend(exports, proto.bet.beteran.c2se.backend.identity);

10
src/app/modules/proto/c2se/backend/member_bank_account_pb.d.ts vendored Normal file
View File

@ -0,0 +1,10 @@
// package: bet.beteran.c2se.backend.member_bank_account
// file: c2se/backend/member_bank_account.proto
import * as jspb from 'google-protobuf';
export const SUBJECT_CREATE_MEMBER_BANK_ACCOUNT: string;
export const SUBJECT_LIST_MEMBER_BANK_ACCOUNTS: string;
export const SUBJECT_GET_MEMBER_BANK_ACCOUNT: string;
export const SUBJECT_UPDATE_MEMBER_BANK_ACCOUNT: string;
export const SUBJECT_DELETE_MEMBER_BANK_ACCOUNT: string;

39
src/app/modules/proto/c2se/backend/member_bank_account_pb.js Normal file
View File

@ -0,0 +1,39 @@
// source: c2se/backend/member_member_bank_account_account.proto
/**
* @fileoverview
* @enhanceable
* @suppress {missingRequire} reports error on implicit type usages.
* @suppress {messageConventions} JS Compiler reports an error if a variable or
* field starts with 'MSG_' and isn't a translatable message.
* @public
*/
// GENERATED CODE -- DO NOT EDIT!
/* eslint-disable */
// @ts-nocheck
var jspb = require("google-protobuf");
var goog = jspb;
var global = function () {
return this || window || global || self || Function("return this")();
}.call(null);
goog.exportSymbol(
"proto.bet.beteran.c2se.backend.member_bank_account",
null,
global
);
proto.bet.beteran.c2se.backend.member_bank_account = {};
proto.bet.beteran.c2se.backend.member_bank_account.SUBJECT_CREATE_MEMBER_BANK_ACCOUNT =
"bet.beteran.c2se.backend.member_bank_account.CreateMemberBankAccount";
proto.bet.beteran.c2se.backend.member_bank_account.SUBJECT_LIST_MEMBER_BANK_ACCOUNTS =
"bet.beteran.c2se.backend.member_bank_account.ListMemberBankAccounts";
proto.bet.beteran.c2se.backend.member_bank_account.SUBJECT_GET_MEMBER_BANK_ACCOUNT =
"bet.beteran.c2se.backend.member_bank_account.GetMemberBankAccount";
proto.bet.beteran.c2se.backend.member_bank_account.SUBJECT_UPDATE_MEMBER_BANK_ACCOUNT =
"bet.beteran.c2se.backend.member_bank_account.UpdateMemberBankAccount";
proto.bet.beteran.c2se.backend.member_bank_account.SUBJECT_DELETE_MEMBER_BANK_ACCOUNT =
"bet.beteran.c2se.backend.member_bank_account.DeleteMemberBankAccount";
goog.object.extend(exports, proto.bet.beteran.c2se.backend.member_bank_account);

11
src/app/modules/proto/c2se/backend/member_bank_deposit_pb.d.ts vendored Normal file
View File

@ -0,0 +1,11 @@
// package: bet.beteran.c2se.backend.member_bank_deposit
// file: c2se/backend/member_bank_deposit.proto
import * as jspb from 'google-protobuf';
export const SUBJECT_CREATE_MEMBER_BANK_DEPOSIT: string;
export const SUBJECT_LIST_MEMBER_BANK_DEPOSITS: string;
export const SUBJECT_GET_MEMBER_BANK_DEPOSIT: string;
export const SUBJECT_UPDATE_MEMBER_BANK_DEPOSIT: string;
export const SUBJECT_UPDATE_MEMBER_BANK_DEPOSIT_FOR_STATE: string;
export const SUBJECT_DELETE_MEMBER_BANK_DEPOSIT: string;

35
src/app/modules/proto/c2se/backend/member_bank_deposit_pb.js Normal file
View File

@ -0,0 +1,35 @@
// source: c2se/backend/member_bank_deposit.proto
/**
* @fileoverview
* @enhanceable
* @suppress {missingRequire} reports error on implicit type usages.
* @suppress {messageConventions} JS Compiler reports an error if a variable or
* field starts with 'MSG_' and isn't a translatable message.
* @public
*/
// GENERATED CODE -- DO NOT EDIT!
/* eslint-disable */
// @ts-nocheck
var jspb = require("google-protobuf");
var goog = jspb;
var global = function () {
return this || window || global || self || Function("return this")();
}.call(null);
proto.bet.beteran.c2se.backend.member_bank_deposit = {};
proto.bet.beteran.c2se.backend.member_bank_deposit.SUBJECT_CREATE_MEMBER_BANK_DEPOSIT =
"bet.beteran.c2se.backend.member_bank_deposit.CreateMemberBankDeposit";
proto.bet.beteran.c2se.backend.member_bank_deposit.SUBJECT_LIST_MEMBER_BANK_DEPOSITS =
"bet.beteran.c2se.backend.member_bank_deposit.ListMemberBankDeposits";
proto.bet.beteran.c2se.backend.member_bank_deposit.SUBJECT_GET_MEMBER_BANK_DEPOSIT =
"bet.beteran.c2se.backend.member_bank_deposit.GetMemberBankDeposit";
proto.bet.beteran.c2se.backend.member_bank_deposit.SUBJECT_UPDATE_MEMBER_BANK_DEPOSIT =
"bet.beteran.c2se.backend.member_bank_deposit.UpdateMemberBankDeposit";
proto.bet.beteran.c2se.backend.member_bank_deposit.SUBJECT_UPDATE_MEMBER_BANK_DEPOSIT_FOR_STATE =
"bet.beteran.c2se.backend.member_bank_deposit.UpdateMemberBankDepositForState";
proto.bet.beteran.c2se.backend.member_bank_deposit.SUBJECT_DELETE_MEMBER_BANK_DEPOSIT =
"bet.beteran.c2se.backend.member_bank_deposit.DeleteMemberBankDeposit";
goog.object.extend(exports, proto.bet.beteran.c2se.backend.member_bank_deposit);

11
src/app/modules/proto/c2se/backend/member_bank_withdraw_pb.d.ts vendored Normal file
View File

@ -0,0 +1,11 @@
// package: bet.beteran.c2se.backend.member_bank_withdraw
// file: c2se/backend/member_bank_withdraw.proto
import * as jspb from 'google-protobuf';
export const SUBJECT_CREATE_MEMBER_BANK_WITHDRAW: string;
export const SUBJECT_LIST_MEMBER_BANK_WITHDRAWS: string;
export const SUBJECT_GET_MEMBER_BANK_WITHDRAW: string;
export const SUBJECT_UPDATE_MEMBER_BANK_WITHDRAW: string;
export const SUBJECT_UPDATE_MEMBER_BANK_WITHDRAW_FOR_STATE: string;
export const SUBJECT_DELETE_MEMBER_BANK_WITHDRAW: string;

38
src/app/modules/proto/c2se/backend/member_bank_withdraw_pb.js Normal file
View File

@ -0,0 +1,38 @@
// source: c2se/backend/member_bank_withdraw.proto
/**
* @fileoverview
* @enhanceable
* @suppress {missingRequire} reports error on implicit type usages.
* @suppress {messageConventions} JS Compiler reports an error if a variable or
* field starts with 'MSG_' and isn't a translatable message.
* @public
*/
// GENERATED CODE -- DO NOT EDIT!
/* eslint-disable */
// @ts-nocheck
var jspb = require("google-protobuf");
var goog = jspb;
var global = function () {
return this || window || global || self || Function("return this")();
}.call(null);
proto.bet.beteran.c2se.backend.member_bank_withdraw = {};
proto.bet.beteran.c2se.backend.member_bank_withdraw.SUBJECT_CREATE_MEMBER_BANK_WITHDRAW =
"bet.beteran.c2se.backend.member_bank_withdraw.CreateMemberBankWithdraw";
proto.bet.beteran.c2se.backend.member_bank_withdraw.SUBJECT_LIST_MEMBER_BANK_WITHDRAWS =
"bet.beteran.c2se.backend.member_bank_withdraw.ListMemberBankWithdraws";
proto.bet.beteran.c2se.backend.member_bank_withdraw.SUBJECT_GET_MEMBER_BANK_WITHDRAW =
"bet.beteran.c2se.backend.member_bank_withdraw.GetMemberBankWithdraw";
proto.bet.beteran.c2se.backend.member_bank_withdraw.SUBJECT_UPDATE_MEMBER_BANK_WITHDRAW =
"bet.beteran.c2se.backend.member_bank_withdraw.UpdateMemberBankWithdraw";
proto.bet.beteran.c2se.backend.member_bank_withdraw.SUBJECT_UPDATE_MEMBER_BANK_WITHDRAW_FOR_STATE =
"bet.beteran.c2se.backend.member_bank_withdraw.UpdateMemberBankWithdrawForState";
proto.bet.beteran.c2se.backend.member_bank_withdraw.SUBJECT_DELETE_MEMBER_BANK_WITHDRAW =
"bet.beteran.c2se.backend.member_bank_withdraw.DeleteMemberBankWithdraw";
goog.object.extend(
exports,
proto.bet.beteran.c2se.backend.member_bank_withdraw
);

10
src/app/modules/proto/c2se/backend/member_class_pb.d.ts vendored Normal file
View File

@ -0,0 +1,10 @@
// package: bet.beteran.c2se.backend.member_class
// file: c2se/backend/member_class.proto
import * as jspb from 'google-protobuf';
export const SUBJECT_CREATE_MEMBER_CLASS: string;
export const SUBJECT_LIST_MEMBER_CLASSES: string;
export const SUBJECT_GET_MEMBER_CLASS: string;
export const SUBJECT_UPDATE_MEMBER_CLASS: string;
export const SUBJECT_DELETE_MEMBER_CLASS: string;

35
src/app/modules/proto/c2se/backend/member_class_pb.js Normal file
View File

@ -0,0 +1,35 @@
// source: c2se/backend/member_class.proto
/**
* @fileoverview
* @enhanceable
* @suppress {missingRequire} reports error on implicit type usages.
* @suppress {messageConventions} JS Compiler reports an error if a variable or
* field starts with 'MSG_' and isn't a translatable message.
* @public
*/
// GENERATED CODE -- DO NOT EDIT!
/* eslint-disable */
// @ts-nocheck
var jspb = require("google-protobuf");
var goog = jspb;
var global = function () {
return this || window || global || self || Function("return this")();
}.call(null);
goog.exportSymbol("proto.bet.beteran.c2se.backend.member_class", null, global);
proto.bet.beteran.c2se.backend.member_class = {};
proto.bet.beteran.c2se.backend.member_class.SUBJECT_CREATE_MEMBER_CLASS =
"bet.beteran.c2se.backend.member_class.CreateMemberClass";
proto.bet.beteran.c2se.backend.member_class.SUBJECT_LIST_MEMBER_CLASSES =
"bet.beteran.c2se.backend.member_class.ListMemberClasses";
proto.bet.beteran.c2se.backend.member_class.SUBJECT_GET_MEMBER_CLASS =
"bet.beteran.c2se.backend.member_class.GetMemberClass";
proto.bet.beteran.c2se.backend.member_class.SUBJECT_UPDATE_MEMBER_CLASS =
"bet.beteran.c2se.backend.member_class.UpdateMemberClass";
proto.bet.beteran.c2se.backend.member_class.SUBJECT_DELETE_MEMBER_CLASS =
"bet.beteran.c2se.backend.member_class.DeleteMemberClass";
goog.object.extend(exports, proto.bet.beteran.c2se.backend.member_class);

10
src/app/modules/proto/c2se/backend/member_level_pb.d.ts vendored Normal file
View File

@ -0,0 +1,10 @@
// package: bet.beteran.c2se.backend.member_level
// file: c2se/backend/member_level.proto
import * as jspb from 'google-protobuf';
export const SUBJECT_CREATE_MEMBER_LEVEL: string;
export const SUBJECT_LIST_MEMBER_LEVELS: string;
export const SUBJECT_GET_MEMBER_LEVEL: string;
export const SUBJECT_UPDATE_MEMBER_LEVEL: string;
export const SUBJECT_DELETE_MEMBER_LEVEL: string;

35
src/app/modules/proto/c2se/backend/member_level_pb.js Normal file
View File

@ -0,0 +1,35 @@
// source: c2se/backend/member_level.proto
/**
* @fileoverview
* @enhanceable
* @suppress {missingRequire} reports error on implicit type usages.
* @suppress {messageConventions} JS Compiler reports an error if a variable or
* field starts with 'MSG_' and isn't a translatable message.
* @public
*/
// GENERATED CODE -- DO NOT EDIT!
/* eslint-disable */
// @ts-nocheck
var jspb = require("google-protobuf");
var goog = jspb;
var global = function () {
return this || window || global || self || Function("return this")();
}.call(null);
goog.exportSymbol("proto.bet.beteran.c2se.backend.member_level", null, global);
proto.bet.beteran.c2se.backend.member_level = {};
proto.bet.beteran.c2se.backend.member_level.SUBJECT_CREATE_MEMBER_LEVEL =
"bet.beteran.c2se.backend.member_level.CreateMemberLevel";
proto.bet.beteran.c2se.backend.member_level.SUBJECT_LIST_MEMBER_LEVELS =
"bet.beteran.c2se.backend.member_level.ListMemberLevels";
proto.bet.beteran.c2se.backend.member_level.SUBJECT_GET_MEMBER_LEVEL =
"bet.beteran.c2se.backend.member_level.GetMemberLevel";
proto.bet.beteran.c2se.backend.member_level.SUBJECT_UPDATE_MEMBER_LEVEL =
"bet.beteran.c2se.backend.member_level.UpdateMemberLevel";
proto.bet.beteran.c2se.backend.member_level.SUBJECT_DELETE_MEMBER_LEVEL =
"bet.beteran.c2se.backend.member_level.DeleteMemberLevel";
goog.object.extend(exports, proto.bet.beteran.c2se.backend.member_level);

11
src/app/modules/proto/c2se/backend/member_pb.d.ts vendored Normal file
View File

@ -0,0 +1,11 @@
// package: bet.beteran.c2se.backend.member
// file: c2se/backend/member.proto
import * as jspb from 'google-protobuf';
export const SUBJECT_CREATE_MEMBER: string;
export const SUBJECT_LIST_MEMBERS: string;
export const SUBJECT_GET_MEMBER: string;
export const SUBJECT_GET_MEMBER_BY_USERNAME: string;
export const SUBJECT_UPDATE_MEMBER: string;
export const SUBJECT_DELETE_MEMBER: string;

37
src/app/modules/proto/c2se/backend/member_pb.js Normal file
View File

@ -0,0 +1,37 @@
// source: c2se/backend/member.proto
/**
* @fileoverview
* @enhanceable
* @suppress {missingRequire} reports error on implicit type usages.
* @suppress {messageConventions} JS Compiler reports an error if a variable or
* field starts with 'MSG_' and isn't a translatable message.
* @public
*/
// GENERATED CODE -- DO NOT EDIT!
/* eslint-disable */
// @ts-nocheck
var jspb = require("google-protobuf");
var goog = jspb;
var global = function () {
return this || window || global || self || Function("return this")();
}.call(null);
goog.exportSymbol("proto.bet.beteran.c2se.backend.member", null, global);
proto.bet.beteran.c2se.backend.member = {};
proto.bet.beteran.c2se.backend.member.SUBJECT_CREATE_MEMBER =
"bet.beteran.c2se.backend.member.CreateMember";
proto.bet.beteran.c2se.backend.member.SUBJECT_LIST_MEMBERS =
"bet.beteran.c2se.backend.member.ListMembers";
proto.bet.beteran.c2se.backend.member.SUBJECT_GET_MEMBER =
"bet.beteran.c2se.backend.member.GetMember";
proto.bet.beteran.c2se.backend.member.SUBJECT_GET_MEMBER_BY_USERNAME =
"bet.beteran.c2se.backend.member.GetMemberByUsername";
proto.bet.beteran.c2se.backend.member.SUBJECT_UPDATE_MEMBER =
"bet.beteran.c2se.backend.member.UpdateMember";
proto.bet.beteran.c2se.backend.member.SUBJECT_DELETE_MEMBER =
"bet.beteran.c2se.backend.member.DeleteMember";
goog.object.extend(exports, proto.bet.beteran.c2se.backend.member);

10
src/app/modules/proto/c2se/backend/site_pb.d.ts vendored Normal file
View File

@ -0,0 +1,10 @@
// package: bet.beteran.c2se.backend.site
// file: c2se/backend/site.proto
import * as jspb from 'google-protobuf';
export const SUBJECT_CREATE_SITE: string;
export const SUBJECT_LIST_SITES: string;
export const SUBJECT_GET_SITE: string;
export const SUBJECT_UPDATE_SITE: string;
export const SUBJECT_DELETE_SITE: string;

35
src/app/modules/proto/c2se/backend/site_pb.js Normal file
View File

@ -0,0 +1,35 @@
// source: c2se/backend/site.proto
/**
* @fileoverview
* @enhanceable
* @suppress {missingRequire} reports error on implicit type usages.
* @suppress {messageConventions} JS Compiler reports an error if a variable or
* field starts with 'MSG_' and isn't a translatable message.
* @public
*/
// GENERATED CODE -- DO NOT EDIT!
/* eslint-disable */
// @ts-nocheck
var jspb = require("google-protobuf");
var goog = jspb;
var global = function () {
return this || window || global || self || Function("return this")();
}.call(null);
goog.exportSymbol("proto.bet.beteran.c2se.backend.site", null, global);
proto.bet.beteran.c2se.backend.site = {};
proto.bet.beteran.c2se.backend.site.SUBJECT_CREATE_SITE =
"bet.beteran.c2se.backend.site.CreateSite";
proto.bet.beteran.c2se.backend.site.SUBJECT_LIST_SITES =
"bet.beteran.c2se.backend.site.ListSites";
proto.bet.beteran.c2se.backend.site.SUBJECT_GET_SITE =
"bet.beteran.c2se.backend.site.GetSite";
proto.bet.beteran.c2se.backend.site.SUBJECT_UPDATE_SITE =
"bet.beteran.c2se.backend.site.UpdateSite";
proto.bet.beteran.c2se.backend.site.SUBJECT_DELETE_SITE =
"bet.beteran.c2se.backend.site.DeleteSite";
goog.object.extend(exports, proto.bet.beteran.c2se.backend.site);

446
src/app/modules/proto/c2se/bank_pb.d.ts vendored Normal file
View File

@ -0,0 +1,446 @@
// package: bet.beteran.c2se.bank
// file: c2se/bank.proto
import * as jspb from "google-protobuf";
import * as protobuf_rpc_pb from "../protobuf/rpc_pb";
import * as protobuf_pagination_pb from "../protobuf/pagination_pb";
import * as models_bank_pb from "../models/bank_pb";
export class CreateBankRequest extends jspb.Message {
getName(): string;
setName(value: string): void;
getSortOrder(): number;
setSortOrder(value: number): void;
getShow(): boolean;
setShow(value: boolean): void;
getCanUse(): boolean;
setCanUse(value: boolean): void;
hasMemo(): boolean;
clearMemo(): void;
getMemo(): string;
setMemo(value: string): void;
serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): CreateBankRequest.AsObject;
static toObject(includeInstance: boolean, msg: CreateBankRequest): CreateBankRequest.AsObject;
static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
static serializeBinaryToWriter(message: CreateBankRequest, writer: jspb.BinaryWriter): void;
static deserializeBinary(bytes: Uint8Array): CreateBankRequest;
static deserializeBinaryFromReader(message: CreateBankRequest, reader: jspb.BinaryReader): CreateBankRequest;
}
export namespace CreateBankRequest {
export type AsObject = {
name: string,
sortOrder: number,
show: boolean,
canUse: boolean,
memo: string,
}
}
export class CreateBankResponse extends jspb.Message {
hasError(): boolean;
clearError(): void;
getError(): protobuf_rpc_pb.Error | undefined;
setError(value?: protobuf_rpc_pb.Error): void;
hasResult(): boolean;
clearResult(): void;
getResult(): CreateBankResponse.Result | undefined;
setResult(value?: CreateBankResponse.Result): void;
serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): CreateBankResponse.AsObject;
static toObject(includeInstance: boolean, msg: CreateBankResponse): CreateBankResponse.AsObject;
static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
static serializeBinaryToWriter(message: CreateBankResponse, writer: jspb.BinaryWriter): void;
static deserializeBinary(bytes: Uint8Array): CreateBankResponse;
static deserializeBinaryFromReader(message: CreateBankResponse, reader: jspb.BinaryReader): CreateBankResponse;
}
export namespace CreateBankResponse {
export type AsObject = {
error?: protobuf_rpc_pb.Error.AsObject,
result?: CreateBankResponse.Result.AsObject,
}
export class Result extends jspb.Message {
hasBank(): boolean;
clearBank(): void;
getBank(): models_bank_pb.Bank | undefined;
setBank(value?: models_bank_pb.Bank): void;
serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): Result.AsObject;
static toObject(includeInstance: boolean, msg: Result): Result.AsObject;
static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
static serializeBinaryToWriter(message: Result, writer: jspb.BinaryWriter): void;
static deserializeBinary(bytes: Uint8Array): Result;
static deserializeBinaryFromReader(message: Result, reader: jspb.BinaryReader): Result;
}
export namespace Result {
export type AsObject = {
bank?: models_bank_pb.Bank.AsObject,
}
}
}
export class ListBanksRequest extends jspb.Message {
hasPagination(): boolean;
clearPagination(): void;
getPagination(): protobuf_pagination_pb.Pagination | undefined;
setPagination(value?: protobuf_pagination_pb.Pagination): void;
clearSortsList(): void;
getSortsList(): Array<protobuf_pagination_pb.Sort>;
setSortsList(value: Array<protobuf_pagination_pb.Sort>): void;
addSorts(value?: protobuf_pagination_pb.Sort, index?: number): protobuf_pagination_pb.Sort;
hasSearch(): boolean;
clearSearch(): void;
getSearch(): ListBanksRequest.Search | undefined;
setSearch(value?: ListBanksRequest.Search): void;
serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): ListBanksRequest.AsObject;
static toObject(includeInstance: boolean, msg: ListBanksRequest): ListBanksRequest.AsObject;
static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
static serializeBinaryToWriter(message: ListBanksRequest, writer: jspb.BinaryWriter): void;
static deserializeBinary(bytes: Uint8Array): ListBanksRequest;
static deserializeBinaryFromReader(message: ListBanksRequest, reader: jspb.BinaryReader): ListBanksRequest;
}
export namespace ListBanksRequest {
export type AsObject = {
pagination?: protobuf_pagination_pb.Pagination.AsObject,
sortsList: Array<protobuf_pagination_pb.Sort.AsObject>,
search?: ListBanksRequest.Search.AsObject,
}
export class Search extends jspb.Message {
hasNameLike(): boolean;
clearNameLike(): void;
getNameLike(): string;
setNameLike(value: string): void;
hasShow(): boolean;
clearShow(): void;
getShow(): boolean;
setShow(value: boolean): void;
hasCanUse(): boolean;
clearCanUse(): void;
getCanUse(): boolean;
setCanUse(value: boolean): void;
hasMemoLike(): boolean;
clearMemoLike(): void;
getMemoLike(): string;
setMemoLike(value: string): void;
serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): Search.AsObject;
static toObject(includeInstance: boolean, msg: Search): Search.AsObject;
static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
static serializeBinaryToWriter(message: Search, writer: jspb.BinaryWriter): void;
static deserializeBinary(bytes: Uint8Array): Search;
static deserializeBinaryFromReader(message: Search, reader: jspb.BinaryReader): Search;
}
export namespace Search {
export type AsObject = {
nameLike: string,
show: boolean,
canUse: boolean,
memoLike: string,
}
}
}
export class ListBanksResponse extends jspb.Message {
hasError(): boolean;
clearError(): void;
getError(): protobuf_rpc_pb.Error | undefined;
setError(value?: protobuf_rpc_pb.Error): void;
hasResult(): boolean;
clearResult(): void;
getResult(): ListBanksResponse.Result | undefined;
setResult(value?: ListBanksResponse.Result): void;
serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): ListBanksResponse.AsObject;
static toObject(includeInstance: boolean, msg: ListBanksResponse): ListBanksResponse.AsObject;
static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
static serializeBinaryToWriter(message: ListBanksResponse, writer: jspb.BinaryWriter): void;
static deserializeBinary(bytes: Uint8Array): ListBanksResponse;
static deserializeBinaryFromReader(message: ListBanksResponse, reader: jspb.BinaryReader): ListBanksResponse;
}
export namespace ListBanksResponse {
export type AsObject = {
error?: protobuf_rpc_pb.Error.AsObject,
result?: ListBanksResponse.Result.AsObject,
}
export class Result extends jspb.Message {
clearBanksList(): void;
getBanksList(): Array<models_bank_pb.Bank>;
setBanksList(value: Array<models_bank_pb.Bank>): void;
addBanks(value?: models_bank_pb.Bank, index?: number): models_bank_pb.Bank;
serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): Result.AsObject;
static toObject(includeInstance: boolean, msg: Result): Result.AsObject;
static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
static serializeBinaryToWriter(message: Result, writer: jspb.BinaryWriter): void;
static deserializeBinary(bytes: Uint8Array): Result;
static deserializeBinaryFromReader(message: Result, reader: jspb.BinaryReader): Result;
}
export namespace Result {
export type AsObject = {
banksList: Array<models_bank_pb.Bank.AsObject>,
}
}
}
export class GetBankRequest extends jspb.Message {
getId(): string;
setId(value: string): void;
serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): GetBankRequest.AsObject;
static toObject(includeInstance: boolean, msg: GetBankRequest): GetBankRequest.AsObject;
static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
static serializeBinaryToWriter(message: GetBankRequest, writer: jspb.BinaryWriter): void;
static deserializeBinary(bytes: Uint8Array): GetBankRequest;
static deserializeBinaryFromReader(message: GetBankRequest, reader: jspb.BinaryReader): GetBankRequest;
}
export namespace GetBankRequest {
export type AsObject = {
id: string,
}
}
export class GetBankResponse extends jspb.Message {
hasError(): boolean;
clearError(): void;
getError(): protobuf_rpc_pb.Error | undefined;
setError(value?: protobuf_rpc_pb.Error): void;
hasResult(): boolean;
clearResult(): void;
getResult(): GetBankResponse.Result | undefined;
setResult(value?: GetBankResponse.Result): void;
serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): GetBankResponse.AsObject;
static toObject(includeInstance: boolean, msg: GetBankResponse): GetBankResponse.AsObject;
static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
static serializeBinaryToWriter(message: GetBankResponse, writer: jspb.BinaryWriter): void;
static deserializeBinary(bytes: Uint8Array): GetBankResponse;
static deserializeBinaryFromReader(message: GetBankResponse, reader: jspb.BinaryReader): GetBankResponse;
}
export namespace GetBankResponse {
export type AsObject = {
error?: protobuf_rpc_pb.Error.AsObject,
result?: GetBankResponse.Result.AsObject,
}
export class Result extends jspb.Message {
hasBank(): boolean;
clearBank(): void;
getBank(): models_bank_pb.Bank | undefined;
setBank(value?: models_bank_pb.Bank): void;
serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): Result.AsObject;
static toObject(includeInstance: boolean, msg: Result): Result.AsObject;
static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
static serializeBinaryToWriter(message: Result, writer: jspb.BinaryWriter): void;
static deserializeBinary(bytes: Uint8Array): Result;
static deserializeBinaryFromReader(message: Result, reader: jspb.BinaryReader): Result;
}
export namespace Result {
export type AsObject = {
bank?: models_bank_pb.Bank.AsObject,
}
}
}
export class UpdateBankRequest extends jspb.Message {
getId(): string;
setId(value: string): void;
getName(): string;
setName(value: string): void;
getSortOrder(): number;
setSortOrder(value: number): void;
getShow(): boolean;
setShow(value: boolean): void;
getCanUse(): boolean;
setCanUse(value: boolean): void;
hasMemo(): boolean;
clearMemo(): void;
getMemo(): string;
setMemo(value: string): void;
serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): UpdateBankRequest.AsObject;
static toObject(includeInstance: boolean, msg: UpdateBankRequest): UpdateBankRequest.AsObject;
static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
static serializeBinaryToWriter(message: UpdateBankRequest, writer: jspb.BinaryWriter): void;
static deserializeBinary(bytes: Uint8Array): UpdateBankRequest;
static deserializeBinaryFromReader(message: UpdateBankRequest, reader: jspb.BinaryReader): UpdateBankRequest;
}
export namespace UpdateBankRequest {
export type AsObject = {
id: string,
name: string,
sortOrder: number,
show: boolean,
canUse: boolean,
memo: string,
}
}
export class UpdateBankResponse extends jspb.Message {
hasError(): boolean;
clearError(): void;
getError(): protobuf_rpc_pb.Error | undefined;
setError(value?: protobuf_rpc_pb.Error): void;
hasResult(): boolean;
clearResult(): void;
getResult(): UpdateBankResponse.Result | undefined;
setResult(value?: UpdateBankResponse.Result): void;
serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): UpdateBankResponse.AsObject;
static toObject(includeInstance: boolean, msg: UpdateBankResponse): UpdateBankResponse.AsObject;
static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
static serializeBinaryToWriter(message: UpdateBankResponse, writer: jspb.BinaryWriter): void;
static deserializeBinary(bytes: Uint8Array): UpdateBankResponse;
static deserializeBinaryFromReader(message: UpdateBankResponse, reader: jspb.BinaryReader): UpdateBankResponse;
}
export namespace UpdateBankResponse {
export type AsObject = {
error?: protobuf_rpc_pb.Error.AsObject,
result?: UpdateBankResponse.Result.AsObject,
}
export class Result extends jspb.Message {
hasBank(): boolean;
clearBank(): void;
getBank(): models_bank_pb.Bank | undefined;
setBank(value?: models_bank_pb.Bank): void;
serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): Result.AsObject;
static toObject(includeInstance: boolean, msg: Result): Result.AsObject;
static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
static serializeBinaryToWriter(message: Result, writer: jspb.BinaryWriter): void;
static deserializeBinary(bytes: Uint8Array): Result;
static deserializeBinaryFromReader(message: Result, reader: jspb.BinaryReader): Result;
}
export namespace Result {
export type AsObject = {
bank?: models_bank_pb.Bank.AsObject,
}
}
}
export class DeleteBankRequest extends jspb.Message {
getId(): string;
setId(value: string): void;
serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): DeleteBankRequest.AsObject;
static toObject(includeInstance: boolean, msg: DeleteBankRequest): DeleteBankRequest.AsObject;
static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
static serializeBinaryToWriter(message: DeleteBankRequest, writer: jspb.BinaryWriter): void;
static deserializeBinary(bytes: Uint8Array): DeleteBankRequest;
static deserializeBinaryFromReader(message: DeleteBankRequest, reader: jspb.BinaryReader): DeleteBankRequest;
}
export namespace DeleteBankRequest {
export type AsObject = {
id: string,
}
}
export class DeleteBankResponse extends jspb.Message {
hasError(): boolean;
clearError(): void;
getError(): protobuf_rpc_pb.Error | undefined;
setError(value?: protobuf_rpc_pb.Error): void;
hasResult(): boolean;
clearResult(): void;
getResult(): DeleteBankResponse.Result | undefined;
setResult(value?: DeleteBankResponse.Result): void;
serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): DeleteBankResponse.AsObject;
static toObject(includeInstance: boolean, msg: DeleteBankResponse): DeleteBankResponse.AsObject;
static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
static serializeBinaryToWriter(message: DeleteBankResponse, writer: jspb.BinaryWriter): void;
static deserializeBinary(bytes: Uint8Array): DeleteBankResponse;
static deserializeBinaryFromReader(message: DeleteBankResponse, reader: jspb.BinaryReader): DeleteBankResponse;
}
export namespace DeleteBankResponse {
export type AsObject = {
error?: protobuf_rpc_pb.Error.AsObject,
result?: DeleteBankResponse.Result.AsObject,
}
export class Result extends jspb.Message {
serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): Result.AsObject;
static toObject(includeInstance: boolean, msg: Result): Result.AsObject;
static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
static serializeBinaryToWriter(message: Result, writer: jspb.BinaryWriter): void;
static deserializeBinary(bytes: Uint8Array): Result;
static deserializeBinaryFromReader(message: Result, reader: jspb.BinaryReader): Result;
}
export namespace Result {
export type AsObject = {
}
}
}

3480
src/app/modules/proto/c2se/bank_pb.js Normal file
View File

File diff suppressed because it is too large Load Diff

6
src/app/modules/proto/c2se/core/network_pb.d.ts vendored Normal file
View File

@ -0,0 +1,6 @@
// package: bet.beteran.c2se.core.network
// file: c2se/core/network.proto
import * as jspb from 'google-protobuf';
export const HEADER_CLIENT: string;

27
src/app/modules/proto/c2se/core/network_pb.js Normal file
View File

@ -0,0 +1,27 @@
// source: c2se/core/network.proto
/**
* @fileoverview
* @enhanceable
* @suppress {missingRequire} reports error on implicit type usages.
* @suppress {messageConventions} JS Compiler reports an error if a variable or
* field starts with 'MSG_' and isn't a translatable message.
* @public
*/
// GENERATED CODE -- DO NOT EDIT!
/* eslint-disable */
// @ts-nocheck
var jspb = require("google-protobuf");
var goog = jspb;
var global = function () {
return this || window || global || self || Function("return this")();
}.call(null);
goog.exportSymbol("proto.bet.beteran.c2se.core.network", null, global);
proto.bet.beteran.c2se.core.network = {};
proto.bet.beteran.c2se.core.network.HEADER_CLIENT =
"bet.beteran.c2se.core.network.Client";
goog.object.extend(exports, proto.bet.beteran.c2se.core.network);

7
src/app/modules/proto/c2se/frontend/bank_pb.d.ts vendored Normal file
View File

@ -0,0 +1,7 @@
// package: bet.beteran.c2se.frontend.bank
// file: c2se/frontend/bank.proto
import * as jspb from 'google-protobuf';
export const SUBJECT_LIST_BANKS: string;
export const SUBJECT_GET_BANK: string;

29
src/app/modules/proto/c2se/frontend/bank_pb.js Normal file
View File

@ -0,0 +1,29 @@
// source: c2se/frontend/bank.proto
/**
* @fileoverview
* @enhanceable
* @suppress {missingRequire} reports error on implicit type usages.
* @suppress {messageConventions} JS Compiler reports an error if a variable or
* field starts with 'MSG_' and isn't a translatable message.
* @public
*/
// GENERATED CODE -- DO NOT EDIT!
/* eslint-disable */
// @ts-nocheck
var jspb = require("google-protobuf");
var goog = jspb;
var global = function () {
return this || window || global || self || Function("return this")();
}.call(null);
goog.exportSymbol("proto.bet.beteran.c2se.frontend.bank", null, global);
proto.bet.beteran.c2se.frontend.bank = {};
proto.bet.beteran.c2se.frontend.bank.SUBJECT_LIST_BANKS =
"bet.beteran.c2se.frontend.bank.ListBanks";
proto.bet.beteran.c2se.frontend.bank.SUBJECT_GET_BANK =
"bet.beteran.c2se.frontend.bank.GetBank";
goog.object.extend(exports, proto.bet.beteran.c2se.frontend.bank);

9
src/app/modules/proto/c2se/frontend/identity_pb.d.ts vendored Normal file
View File

@ -0,0 +1,9 @@
// package: bet.beteran.c2se.frontend.identity
// file: c2se/frontend/identity.proto
import * as jspb from 'google-protobuf';
export const SUBJECT_CHECK_USERNAME_FOR_DUPLICATION: string;
export const SUBJECT_CHECK_NICKNAME_FOR_DUPLICATION: string;
export const SUBJECT_CAPTCHA: string;
export const SUBJECT_SIGNIN: string;

33
src/app/modules/proto/c2se/frontend/identity_pb.js Normal file
View File

@ -0,0 +1,33 @@
// source: c2se/frontend/identity.proto
/**
* @fileoverview
* @enhanceable
* @suppress {missingRequire} reports error on implicit type usages.
* @suppress {messageConventions} JS Compiler reports an error if a variable or
* field starts with 'MSG_' and isn't a translatable message.
* @public
*/
// GENERATED CODE -- DO NOT EDIT!
/* eslint-disable */
// @ts-nocheck
var jspb = require("google-protobuf");
var goog = jspb;
var global = function () {
return this || window || global || self || Function("return this")();
}.call(null);
goog.exportSymbol("proto.bet.beteran.c2se.frontend.identity", null, global);
proto.bet.beteran.c2se.frontend.identity = {};
proto.bet.beteran.c2se.frontend.identity.SUBJECT_CHECK_USERNAME_FOR_DUPLICATION =
"bet.beteran.c2se.frontend.identity.CheckUsernameForDuplication";
proto.bet.beteran.c2se.frontend.identity.SUBJECT_CHECK_NICKNAME_FOR_DUPLICATION =
"bet.beteran.c2se.frontend.identity.CheckNicknameForDuplication";
proto.bet.beteran.c2se.frontend.identity.SUBJECT_CAPTCHA =
"bet.beteran.c2se.frontend.identity.Captcha";
proto.bet.beteran.c2se.frontend.identity.SUBJECT_SIGNIN =
"bet.beteran.c2se.frontend.identity.Signin";
goog.object.extend(exports, proto.bet.beteran.c2se.frontend.identity);

290
src/app/modules/proto/c2se/identity_pb.d.ts vendored Normal file
View File

@ -0,0 +1,290 @@
// package: bet.beteran.c2se.identity
// file: c2se/identity.proto
import * as jspb from "google-protobuf";
import * as protobuf_rpc_pb from "../protobuf/rpc_pb";
export class CheckUsernameForDuplicationRequest extends jspb.Message {
getUsername(): string;
setUsername(value: string): void;
serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): CheckUsernameForDuplicationRequest.AsObject;
static toObject(includeInstance: boolean, msg: CheckUsernameForDuplicationRequest): CheckUsernameForDuplicationRequest.AsObject;
static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
static serializeBinaryToWriter(message: CheckUsernameForDuplicationRequest, writer: jspb.BinaryWriter): void;
static deserializeBinary(bytes: Uint8Array): CheckUsernameForDuplicationRequest;
static deserializeBinaryFromReader(message: CheckUsernameForDuplicationRequest, reader: jspb.BinaryReader): CheckUsernameForDuplicationRequest;
}
export namespace CheckUsernameForDuplicationRequest {
export type AsObject = {
username: string,
}
}
export class CheckUsernameForDuplicationResponse extends jspb.Message {
hasError(): boolean;
clearError(): void;
getError(): protobuf_rpc_pb.Error | undefined;
setError(value?: protobuf_rpc_pb.Error): void;
hasResult(): boolean;
clearResult(): void;
getResult(): CheckUsernameForDuplicationResponse.Result | undefined;
setResult(value?: CheckUsernameForDuplicationResponse.Result): void;
serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): CheckUsernameForDuplicationResponse.AsObject;
static toObject(includeInstance: boolean, msg: CheckUsernameForDuplicationResponse): CheckUsernameForDuplicationResponse.AsObject;
static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
static serializeBinaryToWriter(message: CheckUsernameForDuplicationResponse, writer: jspb.BinaryWriter): void;
static deserializeBinary(bytes: Uint8Array): CheckUsernameForDuplicationResponse;
static deserializeBinaryFromReader(message: CheckUsernameForDuplicationResponse, reader: jspb.BinaryReader): CheckUsernameForDuplicationResponse;
}
export namespace CheckUsernameForDuplicationResponse {
export type AsObject = {
error?: protobuf_rpc_pb.Error.AsObject,
result?: CheckUsernameForDuplicationResponse.Result.AsObject,
}
export class Result extends jspb.Message {
getDuplicated(): boolean;
setDuplicated(value: boolean): void;
serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): Result.AsObject;
static toObject(includeInstance: boolean, msg: Result): Result.AsObject;
static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
static serializeBinaryToWriter(message: Result, writer: jspb.BinaryWriter): void;
static deserializeBinary(bytes: Uint8Array): Result;
static deserializeBinaryFromReader(message: Result, reader: jspb.BinaryReader): Result;
}
export namespace Result {
export type AsObject = {
duplicated: boolean,
}
}
}
export class CheckNicknameForDuplicationRequest extends jspb.Message {
getNickname(): string;
setNickname(value: string): void;
serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): CheckNicknameForDuplicationRequest.AsObject;
static toObject(includeInstance: boolean, msg: CheckNicknameForDuplicationRequest): CheckNicknameForDuplicationRequest.AsObject;
static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
static serializeBinaryToWriter(message: CheckNicknameForDuplicationRequest, writer: jspb.BinaryWriter): void;
static deserializeBinary(bytes: Uint8Array): CheckNicknameForDuplicationRequest;
static deserializeBinaryFromReader(message: CheckNicknameForDuplicationRequest, reader: jspb.BinaryReader): CheckNicknameForDuplicationRequest;
}
export namespace CheckNicknameForDuplicationRequest {
export type AsObject = {
nickname: string,
}
}
export class CheckNicknameForDuplicationResponse extends jspb.Message {
hasError(): boolean;
clearError(): void;
getError(): protobuf_rpc_pb.Error | undefined;
setError(value?: protobuf_rpc_pb.Error): void;
hasResult(): boolean;
clearResult(): void;
getResult(): CheckNicknameForDuplicationResponse.Result | undefined;
setResult(value?: CheckNicknameForDuplicationResponse.Result): void;
serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): CheckNicknameForDuplicationResponse.AsObject;
static toObject(includeInstance: boolean, msg: CheckNicknameForDuplicationResponse): CheckNicknameForDuplicationResponse.AsObject;
static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
static serializeBinaryToWriter(message: CheckNicknameForDuplicationResponse, writer: jspb.BinaryWriter): void;
static deserializeBinary(bytes: Uint8Array): CheckNicknameForDuplicationResponse;
static deserializeBinaryFromReader(message: CheckNicknameForDuplicationResponse, reader: jspb.BinaryReader): CheckNicknameForDuplicationResponse;
}
export namespace CheckNicknameForDuplicationResponse {
export type AsObject = {
error?: protobuf_rpc_pb.Error.AsObject,
result?: CheckNicknameForDuplicationResponse.Result.AsObject,
}
export class Result extends jspb.Message {
getDuplicated(): boolean;
setDuplicated(value: boolean): void;
serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): Result.AsObject;
static toObject(includeInstance: boolean, msg: Result): Result.AsObject;
static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
static serializeBinaryToWriter(message: Result, writer: jspb.BinaryWriter): void;
static deserializeBinary(bytes: Uint8Array): Result;
static deserializeBinaryFromReader(message: Result, reader: jspb.BinaryReader): Result;
}
export namespace Result {
export type AsObject = {
duplicated: boolean,
}
}
}
export class CaptchaRequest extends jspb.Message {
serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): CaptchaRequest.AsObject;
static toObject(includeInstance: boolean, msg: CaptchaRequest): CaptchaRequest.AsObject;
static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
static serializeBinaryToWriter(message: CaptchaRequest, writer: jspb.BinaryWriter): void;
static deserializeBinary(bytes: Uint8Array): CaptchaRequest;
static deserializeBinaryFromReader(message: CaptchaRequest, reader: jspb.BinaryReader): CaptchaRequest;
}
export namespace CaptchaRequest {
export type AsObject = {
}
}
export class CaptchaResponse extends jspb.Message {
hasError(): boolean;
clearError(): void;
getError(): protobuf_rpc_pb.Error | undefined;
setError(value?: protobuf_rpc_pb.Error): void;
hasResult(): boolean;
clearResult(): void;
getResult(): CaptchaResponse.Result | undefined;
setResult(value?: CaptchaResponse.Result): void;
serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): CaptchaResponse.AsObject;
static toObject(includeInstance: boolean, msg: CaptchaResponse): CaptchaResponse.AsObject;
static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
static serializeBinaryToWriter(message: CaptchaResponse, writer: jspb.BinaryWriter): void;
static deserializeBinary(bytes: Uint8Array): CaptchaResponse;
static deserializeBinaryFromReader(message: CaptchaResponse, reader: jspb.BinaryReader): CaptchaResponse;
}
export namespace CaptchaResponse {
export type AsObject = {
error?: protobuf_rpc_pb.Error.AsObject,
result?: CaptchaResponse.Result.AsObject,
}
export class Result extends jspb.Message {
getSecurityCodeHash(): string;
setSecurityCodeHash(value: string): void;
getImage(): string;
setImage(value: string): void;
serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): Result.AsObject;
static toObject(includeInstance: boolean, msg: Result): Result.AsObject;
static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
static serializeBinaryToWriter(message: Result, writer: jspb.BinaryWriter): void;
static deserializeBinary(bytes: Uint8Array): Result;
static deserializeBinaryFromReader(message: Result, reader: jspb.BinaryReader): Result;
}
export namespace Result {
export type AsObject = {
securityCodeHash: string,
image: string,
}
}
}
export class SigninRequest extends jspb.Message {
getSecurityCodeHash(): string;
setSecurityCodeHash(value: string): void;
getSecurityCode(): string;
setSecurityCode(value: string): void;
getUsername(): string;
setUsername(value: string): void;
getPassword(): string;
setPassword(value: string): void;
serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): SigninRequest.AsObject;
static toObject(includeInstance: boolean, msg: SigninRequest): SigninRequest.AsObject;
static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
static serializeBinaryToWriter(message: SigninRequest, writer: jspb.BinaryWriter): void;
static deserializeBinary(bytes: Uint8Array): SigninRequest;
static deserializeBinaryFromReader(message: SigninRequest, reader: jspb.BinaryReader): SigninRequest;
}
export namespace SigninRequest {
export type AsObject = {
securityCodeHash: string,
securityCode: string,
username: string,
password: string,
}
}
export class SigninResponse extends jspb.Message {
hasError(): boolean;
clearError(): void;
getError(): protobuf_rpc_pb.Error | undefined;
setError(value?: protobuf_rpc_pb.Error): void;
hasResult(): boolean;
clearResult(): void;
getResult(): SigninResponse.Result | undefined;
setResult(value?: SigninResponse.Result): void;
serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): SigninResponse.AsObject;
static toObject(includeInstance: boolean, msg: SigninResponse): SigninResponse.AsObject;
static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
static serializeBinaryToWriter(message: SigninResponse, writer: jspb.BinaryWriter): void;
static deserializeBinary(bytes: Uint8Array): SigninResponse;
static deserializeBinaryFromReader(message: SigninResponse, reader: jspb.BinaryReader): SigninResponse;
}
export namespace SigninResponse {
export type AsObject = {
error?: protobuf_rpc_pb.Error.AsObject,
result?: SigninResponse.Result.AsObject,
}
export class Result extends jspb.Message {
getAccessToken(): string;
setAccessToken(value: string): void;
serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): Result.AsObject;
static toObject(includeInstance: boolean, msg: Result): Result.AsObject;
static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
static serializeBinaryToWriter(message: Result, writer: jspb.BinaryWriter): void;
static deserializeBinary(bytes: Uint8Array): Result;
static deserializeBinaryFromReader(message: Result, reader: jspb.BinaryReader): Result;
}
export namespace Result {
export type AsObject = {
accessToken: string,
}
}
}

2223
src/app/modules/proto/c2se/identity_pb.js Normal file
View File

File diff suppressed because it is too large Load Diff

632
src/app/modules/proto/c2se/member_bank_account_pb.d.ts vendored Normal file
View File

@ -0,0 +1,632 @@
// package: bet.beteran.c2se.member_bank_account
// file: c2se/member_bank_account.proto
import * as jspb from 'google-protobuf';
import * as protobuf_rpc_pb from '../protobuf/rpc_pb';
import * as protobuf_pagination_pb from '../protobuf/pagination_pb';
import * as models_member_bank_account_pb from '../models/member_bank_account_pb';
export class CreateMemberBankAccountRequest extends jspb.Message {
getMemberId(): string;
setMemberId(value: string): void;
getBankId(): string;
setBankId(value: string): void;
getName(): string;
setName(value: string): void;
getAccountNumber(): string;
setAccountNumber(value: string): void;
getExchangePassword(): string;
setExchangePassword(value: string): void;
hasMemo(): boolean;
clearMemo(): void;
getMemo(): string;
setMemo(value: string): void;
serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): CreateMemberBankAccountRequest.AsObject;
static toObject(
includeInstance: boolean,
msg: CreateMemberBankAccountRequest
): CreateMemberBankAccountRequest.AsObject;
static extensions: { [key: number]: jspb.ExtensionFieldInfo<jspb.Message> };
static extensionsBinary: {
[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>;
};
static serializeBinaryToWriter(
message: CreateMemberBankAccountRequest,
writer: jspb.BinaryWriter
): void;
static deserializeBinary(bytes: Uint8Array): CreateMemberBankAccountRequest;
static deserializeBinaryFromReader(
message: CreateMemberBankAccountRequest,
reader: jspb.BinaryReader
): CreateMemberBankAccountRequest;
}
export namespace CreateMemberBankAccountRequest {
export type AsObject = {
memberId: string;
bankId: string;
name: string;
accountNumber: string;
exchangePassword: string;
memo: string;
};
}
export class CreateMemberBankAccountResponse extends jspb.Message {
hasError(): boolean;
clearError(): void;
getError(): protobuf_rpc_pb.Error | undefined;
setError(value?: protobuf_rpc_pb.Error): void;
hasResult(): boolean;
clearResult(): void;
getResult(): CreateMemberBankAccountResponse.Result | undefined;
setResult(value?: CreateMemberBankAccountResponse.Result): void;
serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): CreateMemberBankAccountResponse.AsObject;
static toObject(
includeInstance: boolean,
msg: CreateMemberBankAccountResponse
): CreateMemberBankAccountResponse.AsObject;
static extensions: { [key: number]: jspb.ExtensionFieldInfo<jspb.Message> };
static extensionsBinary: {
[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>;
};
static serializeBinaryToWriter(
message: CreateMemberBankAccountResponse,
writer: jspb.BinaryWriter
): void;
static deserializeBinary(bytes: Uint8Array): CreateMemberBankAccountResponse;
static deserializeBinaryFromReader(
message: CreateMemberBankAccountResponse,
reader: jspb.BinaryReader
): CreateMemberBankAccountResponse;
}
export namespace CreateMemberBankAccountResponse {
export type AsObject = {
error?: protobuf_rpc_pb.Error.AsObject;
result?: CreateMemberBankAccountResponse.Result.AsObject;
};
export class Result extends jspb.Message {
hasMemberBankAccount(): boolean;
clearMemberBankAccount(): void;
getMemberBankAccount():
| models_member_bank_account_pb.MemberBankAccount
| undefined;
setMemberBankAccount(
value?: models_member_bank_account_pb.MemberBankAccount
): void;
serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): Result.AsObject;
static toObject(includeInstance: boolean, msg: Result): Result.AsObject;
static extensions: { [key: number]: jspb.ExtensionFieldInfo<jspb.Message> };
static extensionsBinary: {
[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>;
};
static serializeBinaryToWriter(
message: Result,
writer: jspb.BinaryWriter
): void;
static deserializeBinary(bytes: Uint8Array): Result;
static deserializeBinaryFromReader(
message: Result,
reader: jspb.BinaryReader
): Result;
}
export namespace Result {
export type AsObject = {
memberBankAccount?: models_member_bank_account_pb.MemberBankAccount.AsObject;
};
}
}
export class ListMemberBankAccountsRequest extends jspb.Message {
hasPagination(): boolean;
clearPagination(): void;
getPagination(): protobuf_pagination_pb.Pagination | undefined;
setPagination(value?: protobuf_pagination_pb.Pagination): void;
clearSortsList(): void;
getSortsList(): Array<protobuf_pagination_pb.Sort>;
setSortsList(value: Array<protobuf_pagination_pb.Sort>): void;
addSorts(
value?: protobuf_pagination_pb.Sort,
index?: number
): protobuf_pagination_pb.Sort;
hasSearch(): boolean;
clearSearch(): void;
getSearch(): ListMemberBankAccountsRequest.Search | undefined;
setSearch(value?: ListMemberBankAccountsRequest.Search): void;
serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): ListMemberBankAccountsRequest.AsObject;
static toObject(
includeInstance: boolean,
msg: ListMemberBankAccountsRequest
): ListMemberBankAccountsRequest.AsObject;
static extensions: { [key: number]: jspb.ExtensionFieldInfo<jspb.Message> };
static extensionsBinary: {
[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>;
};
static serializeBinaryToWriter(
message: ListMemberBankAccountsRequest,
writer: jspb.BinaryWriter
): void;
static deserializeBinary(bytes: Uint8Array): ListMemberBankAccountsRequest;
static deserializeBinaryFromReader(
message: ListMemberBankAccountsRequest,
reader: jspb.BinaryReader
): ListMemberBankAccountsRequest;
}
export namespace ListMemberBankAccountsRequest {
export type AsObject = {
pagination?: protobuf_pagination_pb.Pagination.AsObject;
sortsList: Array<protobuf_pagination_pb.Sort.AsObject>;
search?: ListMemberBankAccountsRequest.Search.AsObject;
};
export class Search extends jspb.Message {
hasMemberId(): boolean;
clearMemberId(): void;
getMemberId(): string;
setMemberId(value: string): void;
hasBankId(): boolean;
clearBankId(): void;
getBankId(): string;
setBankId(value: string): void;
hasNameLike(): boolean;
clearNameLike(): void;
getNameLike(): string;
setNameLike(value: string): void;
hasAccountNumberLike(): boolean;
clearAccountNumberLike(): void;
getAccountNumberLike(): string;
setAccountNumberLike(value: string): void;
hasMemoLike(): boolean;
clearMemoLike(): void;
getMemoLike(): string;
setMemoLike(value: string): void;
serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): Search.AsObject;
static toObject(includeInstance: boolean, msg: Search): Search.AsObject;
static extensions: { [key: number]: jspb.ExtensionFieldInfo<jspb.Message> };
static extensionsBinary: {
[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>;
};
static serializeBinaryToWriter(
message: Search,
writer: jspb.BinaryWriter
): void;
static deserializeBinary(bytes: Uint8Array): Search;
static deserializeBinaryFromReader(
message: Search,
reader: jspb.BinaryReader
): Search;
}
export namespace Search {
export type AsObject = {
memberId: string;
bankId: string;
nameLike: string;
accountNumberLike: string;
memoLike: string;
};
}
}
export class ListMemberBankAccountsResponse extends jspb.Message {
hasError(): boolean;
clearError(): void;
getError(): protobuf_rpc_pb.Error | undefined;
setError(value?: protobuf_rpc_pb.Error): void;
hasResult(): boolean;
clearResult(): void;
getResult(): ListMemberBankAccountsResponse.Result | undefined;
setResult(value?: ListMemberBankAccountsResponse.Result): void;
serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): ListMemberBankAccountsResponse.AsObject;
static toObject(
includeInstance: boolean,
msg: ListMemberBankAccountsResponse
): ListMemberBankAccountsResponse.AsObject;
static extensions: { [key: number]: jspb.ExtensionFieldInfo<jspb.Message> };
static extensionsBinary: {
[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>;
};
static serializeBinaryToWriter(
message: ListMemberBankAccountsResponse,
writer: jspb.BinaryWriter
): void;
static deserializeBinary(bytes: Uint8Array): ListMemberBankAccountsResponse;
static deserializeBinaryFromReader(
message: ListMemberBankAccountsResponse,
reader: jspb.BinaryReader
): ListMemberBankAccountsResponse;
}
export namespace ListMemberBankAccountsResponse {
export type AsObject = {
error?: protobuf_rpc_pb.Error.AsObject;
result?: ListMemberBankAccountsResponse.Result.AsObject;
};
export class Result extends jspb.Message {
clearMemberBankAccountsList(): void;
getMemberBankAccountsList(): Array<models_member_bank_account_pb.MemberBankAccount>;
setMemberBankAccountsList(
value: Array<models_member_bank_account_pb.MemberBankAccount>
): void;
addMemberBankAccounts(
value?: models_member_bank_account_pb.MemberBankAccount,
index?: number
): models_member_bank_account_pb.MemberBankAccount;
serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): Result.AsObject;
static toObject(includeInstance: boolean, msg: Result): Result.AsObject;
static extensions: { [key: number]: jspb.ExtensionFieldInfo<jspb.Message> };
static extensionsBinary: {
[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>;
};
static serializeBinaryToWriter(
message: Result,
writer: jspb.BinaryWriter
): void;
static deserializeBinary(bytes: Uint8Array): Result;
static deserializeBinaryFromReader(
message: Result,
reader: jspb.BinaryReader
): Result;
}
export namespace Result {
export type AsObject = {
memberBankAccountsList: Array<models_member_bank_account_pb.MemberBankAccount.AsObject>;
};
}
}
export class GetMemberBankAccountRequest extends jspb.Message {
getId(): string;
setId(value: string): void;
serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): GetMemberBankAccountRequest.AsObject;
static toObject(
includeInstance: boolean,
msg: GetMemberBankAccountRequest
): GetMemberBankAccountRequest.AsObject;
static extensions: { [key: number]: jspb.ExtensionFieldInfo<jspb.Message> };
static extensionsBinary: {
[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>;
};
static serializeBinaryToWriter(
message: GetMemberBankAccountRequest,
writer: jspb.BinaryWriter
): void;
static deserializeBinary(bytes: Uint8Array): GetMemberBankAccountRequest;
static deserializeBinaryFromReader(
message: GetMemberBankAccountRequest,
reader: jspb.BinaryReader
): GetMemberBankAccountRequest;
}
export namespace GetMemberBankAccountRequest {
export type AsObject = {
id: string;
};
}
export class GetMemberBankAccountResponse extends jspb.Message {
hasError(): boolean;
clearError(): void;
getError(): protobuf_rpc_pb.Error | undefined;
setError(value?: protobuf_rpc_pb.Error): void;
hasResult(): boolean;
clearResult(): void;
getResult(): GetMemberBankAccountResponse.Result | undefined;
setResult(value?: GetMemberBankAccountResponse.Result): void;
serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): GetMemberBankAccountResponse.AsObject;
static toObject(
includeInstance: boolean,
msg: GetMemberBankAccountResponse
): GetMemberBankAccountResponse.AsObject;
static extensions: { [key: number]: jspb.ExtensionFieldInfo<jspb.Message> };
static extensionsBinary: {
[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>;
};
static serializeBinaryToWriter(
message: GetMemberBankAccountResponse,
writer: jspb.BinaryWriter
): void;
static deserializeBinary(bytes: Uint8Array): GetMemberBankAccountResponse;
static deserializeBinaryFromReader(
message: GetMemberBankAccountResponse,
reader: jspb.BinaryReader
): GetMemberBankAccountResponse;
}
export namespace GetMemberBankAccountResponse {
export type AsObject = {
error?: protobuf_rpc_pb.Error.AsObject;
result?: GetMemberBankAccountResponse.Result.AsObject;
};
export class Result extends jspb.Message {
hasMemberBankAccount(): boolean;
clearMemberBankAccount(): void;
getMemberBankAccount():
| models_member_bank_account_pb.MemberBankAccount
| undefined;
setMemberBankAccount(
value?: models_member_bank_account_pb.MemberBankAccount
): void;
serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): Result.AsObject;
static toObject(includeInstance: boolean, msg: Result): Result.AsObject;
static extensions: { [key: number]: jspb.ExtensionFieldInfo<jspb.Message> };
static extensionsBinary: {
[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>;
};
static serializeBinaryToWriter(
message: Result,
writer: jspb.BinaryWriter
): void;
static deserializeBinary(bytes: Uint8Array): Result;
static deserializeBinaryFromReader(
message: Result,
reader: jspb.BinaryReader
): Result;
}
export namespace Result {
export type AsObject = {
memberBankAccount?: models_member_bank_account_pb.MemberBankAccount.AsObject;
};
}
}
export class UpdateMemberBankAccountRequest extends jspb.Message {
getId(): string;
setId(value: string): void;
getBankId(): string;
setBankId(value: string): void;
getName(): string;
setName(value: string): void;
getAccountNumber(): string;
setAccountNumber(value: string): void;
getExchangePassword(): string;
setExchangePassword(value: string): void;
hasMemo(): boolean;
clearMemo(): void;
getMemo(): string;
setMemo(value: string): void;
serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): UpdateMemberBankAccountRequest.AsObject;
static toObject(
includeInstance: boolean,
msg: UpdateMemberBankAccountRequest
): UpdateMemberBankAccountRequest.AsObject;
static extensions: { [key: number]: jspb.ExtensionFieldInfo<jspb.Message> };
static extensionsBinary: {
[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>;
};
static serializeBinaryToWriter(
message: UpdateMemberBankAccountRequest,
writer: jspb.BinaryWriter
): void;
static deserializeBinary(bytes: Uint8Array): UpdateMemberBankAccountRequest;
static deserializeBinaryFromReader(
message: UpdateMemberBankAccountRequest,
reader: jspb.BinaryReader
): UpdateMemberBankAccountRequest;
}
export namespace UpdateMemberBankAccountRequest {
export type AsObject = {
id: string;
bankId: string;
name: string;
accountNumber: string;
exchangePassword: string;
memo: string;
};
}
export class UpdateMemberBankAccountResponse extends jspb.Message {
hasError(): boolean;
clearError(): void;
getError(): protobuf_rpc_pb.Error | undefined;
setError(value?: protobuf_rpc_pb.Error): void;
hasResult(): boolean;
clearResult(): void;
getResult(): UpdateMemberBankAccountResponse.Result | undefined;
setResult(value?: UpdateMemberBankAccountResponse.Result): void;
serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): UpdateMemberBankAccountResponse.AsObject;
static toObject(
includeInstance: boolean,
msg: UpdateMemberBankAccountResponse
): UpdateMemberBankAccountResponse.AsObject;
static extensions: { [key: number]: jspb.ExtensionFieldInfo<jspb.Message> };
static extensionsBinary: {
[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>;
};
static serializeBinaryToWriter(
message: UpdateMemberBankAccountResponse,
writer: jspb.BinaryWriter
): void;
static deserializeBinary(bytes: Uint8Array): UpdateMemberBankAccountResponse;
static deserializeBinaryFromReader(
message: UpdateMemberBankAccountResponse,
reader: jspb.BinaryReader
): UpdateMemberBankAccountResponse;
}
export namespace UpdateMemberBankAccountResponse {
export type AsObject = {
error?: protobuf_rpc_pb.Error.AsObject;
result?: UpdateMemberBankAccountResponse.Result.AsObject;
};
export class Result extends jspb.Message {
hasMemberBankAccount(): boolean;
clearMemberBankAccount(): void;
getMemberBankAccount():
| models_member_bank_account_pb.MemberBankAccount
| undefined;
setMemberBankAccount(
value?: models_member_bank_account_pb.MemberBankAccount
): void;
serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): Result.AsObject;
static toObject(includeInstance: boolean, msg: Result): Result.AsObject;
static extensions: { [key: number]: jspb.ExtensionFieldInfo<jspb.Message> };
static extensionsBinary: {
[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>;
};
static serializeBinaryToWriter(
message: Result,
writer: jspb.BinaryWriter
): void;
static deserializeBinary(bytes: Uint8Array): Result;
static deserializeBinaryFromReader(
message: Result,
reader: jspb.BinaryReader
): Result;
}
export namespace Result {
export type AsObject = {
memberBankAccount?: models_member_bank_account_pb.MemberBankAccount.AsObject;
};
}
}
export class DeleteMemberBankAccountRequest extends jspb.Message {
getId(): string;
setId(value: string): void;
serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): DeleteMemberBankAccountRequest.AsObject;
static toObject(
includeInstance: boolean,
msg: DeleteMemberBankAccountRequest
): DeleteMemberBankAccountRequest.AsObject;
static extensions: { [key: number]: jspb.ExtensionFieldInfo<jspb.Message> };
static extensionsBinary: {
[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>;
};
static serializeBinaryToWriter(
message: DeleteMemberBankAccountRequest,
writer: jspb.BinaryWriter
): void;
static deserializeBinary(bytes: Uint8Array): DeleteMemberBankAccountRequest;
static deserializeBinaryFromReader(
message: DeleteMemberBankAccountRequest,
reader: jspb.BinaryReader
): DeleteMemberBankAccountRequest;
}
export namespace DeleteMemberBankAccountRequest {
export type AsObject = {
id: string;
};
}
export class DeleteMemberBankAccountResponse extends jspb.Message {
hasError(): boolean;
clearError(): void;
getError(): protobuf_rpc_pb.Error | undefined;
setError(value?: protobuf_rpc_pb.Error): void;
hasResult(): boolean;
clearResult(): void;
getResult(): DeleteMemberBankAccountResponse.Result | undefined;
setResult(value?: DeleteMemberBankAccountResponse.Result): void;
serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): DeleteMemberBankAccountResponse.AsObject;
static toObject(
includeInstance: boolean,
msg: DeleteMemberBankAccountResponse
): DeleteMemberBankAccountResponse.AsObject;
static extensions: { [key: number]: jspb.ExtensionFieldInfo<jspb.Message> };
static extensionsBinary: {
[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>;
};
static serializeBinaryToWriter(
message: DeleteMemberBankAccountResponse,
writer: jspb.BinaryWriter
): void;
static deserializeBinary(bytes: Uint8Array): DeleteMemberBankAccountResponse;
static deserializeBinaryFromReader(
message: DeleteMemberBankAccountResponse,
reader: jspb.BinaryReader
): DeleteMemberBankAccountResponse;
}
export namespace DeleteMemberBankAccountResponse {
export type AsObject = {
error?: protobuf_rpc_pb.Error.AsObject;
result?: DeleteMemberBankAccountResponse.Result.AsObject;
};
export class Result extends jspb.Message {
serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): Result.AsObject;
static toObject(includeInstance: boolean, msg: Result): Result.AsObject;
static extensions: { [key: number]: jspb.ExtensionFieldInfo<jspb.Message> };
static extensionsBinary: {
[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>;
};
static serializeBinaryToWriter(
message: Result,
writer: jspb.BinaryWriter
): void;
static deserializeBinary(bytes: Uint8Array): Result;
static deserializeBinaryFromReader(
message: Result,
reader: jspb.BinaryReader
): Result;
}
export namespace Result {
export type AsObject = {};
}
}

4030
src/app/modules/proto/c2se/member_bank_account_pb.js Normal file
View File

File diff suppressed because it is too large Load Diff

510
src/app/modules/proto/c2se/member_bank_deposit_pb.d.ts vendored Normal file
View File

@ -0,0 +1,510 @@
// package: bet.beteran.c2se.member_bank_deposit
// file: c2se/member_bank_deposit.proto
import * as jspb from "google-protobuf";
import * as protobuf_rpc_pb from "../protobuf/rpc_pb";
import * as protobuf_pagination_pb from "../protobuf/pagination_pb";
import * as models_member_bank_deposit_pb from "../models/member_bank_deposit_pb";
export class CreateMemberBankDepositRequest extends jspb.Message {
getName(): string;
setName(value: string): void;
getAmount(): number;
setAmount(value: number): void;
hasMemo(): boolean;
clearMemo(): void;
getMemo(): string;
setMemo(value: string): void;
serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): CreateMemberBankDepositRequest.AsObject;
static toObject(includeInstance: boolean, msg: CreateMemberBankDepositRequest): CreateMemberBankDepositRequest.AsObject;
static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
static serializeBinaryToWriter(message: CreateMemberBankDepositRequest, writer: jspb.BinaryWriter): void;
static deserializeBinary(bytes: Uint8Array): CreateMemberBankDepositRequest;
static deserializeBinaryFromReader(message: CreateMemberBankDepositRequest, reader: jspb.BinaryReader): CreateMemberBankDepositRequest;
}
export namespace CreateMemberBankDepositRequest {
export type AsObject = {
name: string,
amount: number,
memo: string,
}
}
export class CreateMemberBankDepositResponse extends jspb.Message {
hasError(): boolean;
clearError(): void;
getError(): protobuf_rpc_pb.Error | undefined;
setError(value?: protobuf_rpc_pb.Error): void;
hasResult(): boolean;
clearResult(): void;
getResult(): CreateMemberBankDepositResponse.Result | undefined;
setResult(value?: CreateMemberBankDepositResponse.Result): void;
serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): CreateMemberBankDepositResponse.AsObject;
static toObject(includeInstance: boolean, msg: CreateMemberBankDepositResponse): CreateMemberBankDepositResponse.AsObject;
static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
static serializeBinaryToWriter(message: CreateMemberBankDepositResponse, writer: jspb.BinaryWriter): void;
static deserializeBinary(bytes: Uint8Array): CreateMemberBankDepositResponse;
static deserializeBinaryFromReader(message: CreateMemberBankDepositResponse, reader: jspb.BinaryReader): CreateMemberBankDepositResponse;
}
export namespace CreateMemberBankDepositResponse {
export type AsObject = {
error?: protobuf_rpc_pb.Error.AsObject,
result?: CreateMemberBankDepositResponse.Result.AsObject,
}
export class Result extends jspb.Message {
hasMemberBankDeposit(): boolean;
clearMemberBankDeposit(): void;
getMemberBankDeposit(): models_member_bank_deposit_pb.MemberBankDeposit | undefined;
setMemberBankDeposit(value?: models_member_bank_deposit_pb.MemberBankDeposit): void;
serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): Result.AsObject;
static toObject(includeInstance: boolean, msg: Result): Result.AsObject;
static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
static serializeBinaryToWriter(message: Result, writer: jspb.BinaryWriter): void;
static deserializeBinary(bytes: Uint8Array): Result;
static deserializeBinaryFromReader(message: Result, reader: jspb.BinaryReader): Result;
}
export namespace Result {
export type AsObject = {
memberBankDeposit?: models_member_bank_deposit_pb.MemberBankDeposit.AsObject,
}
}
}
export class ListMemberBankDepositsRequest extends jspb.Message {
hasPagination(): boolean;
clearPagination(): void;
getPagination(): protobuf_pagination_pb.Pagination | undefined;
setPagination(value?: protobuf_pagination_pb.Pagination): void;
clearSortsList(): void;
getSortsList(): Array<protobuf_pagination_pb.Sort>;
setSortsList(value: Array<protobuf_pagination_pb.Sort>): void;
addSorts(value?: protobuf_pagination_pb.Sort, index?: number): protobuf_pagination_pb.Sort;
hasSearch(): boolean;
clearSearch(): void;
getSearch(): ListMemberBankDepositsRequest.Search | undefined;
setSearch(value?: ListMemberBankDepositsRequest.Search): void;
serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): ListMemberBankDepositsRequest.AsObject;
static toObject(includeInstance: boolean, msg: ListMemberBankDepositsRequest): ListMemberBankDepositsRequest.AsObject;
static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
static serializeBinaryToWriter(message: ListMemberBankDepositsRequest, writer: jspb.BinaryWriter): void;
static deserializeBinary(bytes: Uint8Array): ListMemberBankDepositsRequest;
static deserializeBinaryFromReader(message: ListMemberBankDepositsRequest, reader: jspb.BinaryReader): ListMemberBankDepositsRequest;
}
export namespace ListMemberBankDepositsRequest {
export type AsObject = {
pagination?: protobuf_pagination_pb.Pagination.AsObject,
sortsList: Array<protobuf_pagination_pb.Sort.AsObject>,
search?: ListMemberBankDepositsRequest.Search.AsObject,
}
export class Search extends jspb.Message {
hasMemberId(): boolean;
clearMemberId(): void;
getMemberId(): string;
setMemberId(value: string): void;
hasNameLike(): boolean;
clearNameLike(): void;
getNameLike(): string;
setNameLike(value: string): void;
hasAmount(): boolean;
clearAmount(): void;
getAmount(): number;
setAmount(value: number): void;
hasMemoLike(): boolean;
clearMemoLike(): void;
getMemoLike(): string;
setMemoLike(value: string): void;
hasState(): boolean;
clearState(): void;
getState(): models_member_bank_deposit_pb.MemberBankDepositStateMap[keyof models_member_bank_deposit_pb.MemberBankDepositStateMap];
setState(value: models_member_bank_deposit_pb.MemberBankDepositStateMap[keyof models_member_bank_deposit_pb.MemberBankDepositStateMap]): void;
serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): Search.AsObject;
static toObject(includeInstance: boolean, msg: Search): Search.AsObject;
static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
static serializeBinaryToWriter(message: Search, writer: jspb.BinaryWriter): void;
static deserializeBinary(bytes: Uint8Array): Search;
static deserializeBinaryFromReader(message: Search, reader: jspb.BinaryReader): Search;
}
export namespace Search {
export type AsObject = {
memberId: string,
nameLike: string,
amount: number,
memoLike: string,
state: models_member_bank_deposit_pb.MemberBankDepositStateMap[keyof models_member_bank_deposit_pb.MemberBankDepositStateMap],
}
}
}
export class ListMemberBankDepositsResponse extends jspb.Message {
hasError(): boolean;
clearError(): void;
getError(): protobuf_rpc_pb.Error | undefined;
setError(value?: protobuf_rpc_pb.Error): void;
hasResult(): boolean;
clearResult(): void;
getResult(): ListMemberBankDepositsResponse.Result | undefined;
setResult(value?: ListMemberBankDepositsResponse.Result): void;
serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): ListMemberBankDepositsResponse.AsObject;
static toObject(includeInstance: boolean, msg: ListMemberBankDepositsResponse): ListMemberBankDepositsResponse.AsObject;
static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
static serializeBinaryToWriter(message: ListMemberBankDepositsResponse, writer: jspb.BinaryWriter): void;
static deserializeBinary(bytes: Uint8Array): ListMemberBankDepositsResponse;
static deserializeBinaryFromReader(message: ListMemberBankDepositsResponse, reader: jspb.BinaryReader): ListMemberBankDepositsResponse;
}
export namespace ListMemberBankDepositsResponse {
export type AsObject = {
error?: protobuf_rpc_pb.Error.AsObject,
result?: ListMemberBankDepositsResponse.Result.AsObject,
}
export class Result extends jspb.Message {
clearMemberBankDepositsList(): void;
getMemberBankDepositsList(): Array<models_member_bank_deposit_pb.MemberBankDeposit>;
setMemberBankDepositsList(value: Array<models_member_bank_deposit_pb.MemberBankDeposit>): void;
addMemberBankDeposits(value?: models_member_bank_deposit_pb.MemberBankDeposit, index?: number): models_member_bank_deposit_pb.MemberBankDeposit;
serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): Result.AsObject;
static toObject(includeInstance: boolean, msg: Result): Result.AsObject;
static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
static serializeBinaryToWriter(message: Result, writer: jspb.BinaryWriter): void;
static deserializeBinary(bytes: Uint8Array): Result;
static deserializeBinaryFromReader(message: Result, reader: jspb.BinaryReader): Result;
}
export namespace Result {
export type AsObject = {
memberBankDepositsList: Array<models_member_bank_deposit_pb.MemberBankDeposit.AsObject>,
}
}
}
export class GetMemberBankDepositRequest extends jspb.Message {
getId(): string;
setId(value: string): void;
serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): GetMemberBankDepositRequest.AsObject;
static toObject(includeInstance: boolean, msg: GetMemberBankDepositRequest): GetMemberBankDepositRequest.AsObject;
static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
static serializeBinaryToWriter(message: GetMemberBankDepositRequest, writer: jspb.BinaryWriter): void;
static deserializeBinary(bytes: Uint8Array): GetMemberBankDepositRequest;
static deserializeBinaryFromReader(message: GetMemberBankDepositRequest, reader: jspb.BinaryReader): GetMemberBankDepositRequest;
}
export namespace GetMemberBankDepositRequest {
export type AsObject = {
id: string,
}
}
export class GetMemberBankDepositResponse extends jspb.Message {
hasError(): boolean;
clearError(): void;
getError(): protobuf_rpc_pb.Error | undefined;
setError(value?: protobuf_rpc_pb.Error): void;
hasResult(): boolean;
clearResult(): void;
getResult(): GetMemberBankDepositResponse.Result | undefined;
setResult(value?: GetMemberBankDepositResponse.Result): void;
serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): GetMemberBankDepositResponse.AsObject;
static toObject(includeInstance: boolean, msg: GetMemberBankDepositResponse): GetMemberBankDepositResponse.AsObject;
static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
static serializeBinaryToWriter(message: GetMemberBankDepositResponse, writer: jspb.BinaryWriter): void;
static deserializeBinary(bytes: Uint8Array): GetMemberBankDepositResponse;
static deserializeBinaryFromReader(message: GetMemberBankDepositResponse, reader: jspb.BinaryReader): GetMemberBankDepositResponse;
}
export namespace GetMemberBankDepositResponse {
export type AsObject = {
error?: protobuf_rpc_pb.Error.AsObject,
result?: GetMemberBankDepositResponse.Result.AsObject,
}
export class Result extends jspb.Message {
hasMemberBankDeposit(): boolean;
clearMemberBankDeposit(): void;
getMemberBankDeposit(): models_member_bank_deposit_pb.MemberBankDeposit | undefined;
setMemberBankDeposit(value?: models_member_bank_deposit_pb.MemberBankDeposit): void;
serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): Result.AsObject;
static toObject(includeInstance: boolean, msg: Result): Result.AsObject;
static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
static serializeBinaryToWriter(message: Result, writer: jspb.BinaryWriter): void;
static deserializeBinary(bytes: Uint8Array): Result;
static deserializeBinaryFromReader(message: Result, reader: jspb.BinaryReader): Result;
}
export namespace Result {
export type AsObject = {
memberBankDeposit?: models_member_bank_deposit_pb.MemberBankDeposit.AsObject,
}
}
}
export class UpdateMemberBankDepositRequest extends jspb.Message {
getId(): string;
setId(value: string): void;
getName(): string;
setName(value: string): void;
getAmount(): number;
setAmount(value: number): void;
hasMemo(): boolean;
clearMemo(): void;
getMemo(): string;
setMemo(value: string): void;
serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): UpdateMemberBankDepositRequest.AsObject;
static toObject(includeInstance: boolean, msg: UpdateMemberBankDepositRequest): UpdateMemberBankDepositRequest.AsObject;
static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
static serializeBinaryToWriter(message: UpdateMemberBankDepositRequest, writer: jspb.BinaryWriter): void;
static deserializeBinary(bytes: Uint8Array): UpdateMemberBankDepositRequest;
static deserializeBinaryFromReader(message: UpdateMemberBankDepositRequest, reader: jspb.BinaryReader): UpdateMemberBankDepositRequest;
}
export namespace UpdateMemberBankDepositRequest {
export type AsObject = {
id: string,
name: string,
amount: number,
memo: string,
}
}
export class UpdateMemberBankDepositResponse extends jspb.Message {
hasError(): boolean;
clearError(): void;
getError(): protobuf_rpc_pb.Error | undefined;
setError(value?: protobuf_rpc_pb.Error): void;
hasResult(): boolean;
clearResult(): void;
getResult(): UpdateMemberBankDepositResponse.Result | undefined;
setResult(value?: UpdateMemberBankDepositResponse.Result): void;
serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): UpdateMemberBankDepositResponse.AsObject;
static toObject(includeInstance: boolean, msg: UpdateMemberBankDepositResponse): UpdateMemberBankDepositResponse.AsObject;
static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
static serializeBinaryToWriter(message: UpdateMemberBankDepositResponse, writer: jspb.BinaryWriter): void;
static deserializeBinary(bytes: Uint8Array): UpdateMemberBankDepositResponse;
static deserializeBinaryFromReader(message: UpdateMemberBankDepositResponse, reader: jspb.BinaryReader): UpdateMemberBankDepositResponse;
}
export namespace UpdateMemberBankDepositResponse {
export type AsObject = {
error?: protobuf_rpc_pb.Error.AsObject,
result?: UpdateMemberBankDepositResponse.Result.AsObject,
}
export class Result extends jspb.Message {
hasMemberBankDeposit(): boolean;
clearMemberBankDeposit(): void;
getMemberBankDeposit(): models_member_bank_deposit_pb.MemberBankDeposit | undefined;
setMemberBankDeposit(value?: models_member_bank_deposit_pb.MemberBankDeposit): void;
serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): Result.AsObject;
static toObject(includeInstance: boolean, msg: Result): Result.AsObject;
static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
static serializeBinaryToWriter(message: Result, writer: jspb.BinaryWriter): void;
static deserializeBinary(bytes: Uint8Array): Result;
static deserializeBinaryFromReader(message: Result, reader: jspb.BinaryReader): Result;
}
export namespace Result {
export type AsObject = {
memberBankDeposit?: models_member_bank_deposit_pb.MemberBankDeposit.AsObject,
}
}
}
export class UpdateMemberBankDepositForStateRequest extends jspb.Message {
getId(): string;
setId(value: string): void;
getState(): models_member_bank_deposit_pb.MemberBankDepositStateMap[keyof models_member_bank_deposit_pb.MemberBankDepositStateMap];
setState(value: models_member_bank_deposit_pb.MemberBankDepositStateMap[keyof models_member_bank_deposit_pb.MemberBankDepositStateMap]): void;
serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): UpdateMemberBankDepositForStateRequest.AsObject;
static toObject(includeInstance: boolean, msg: UpdateMemberBankDepositForStateRequest): UpdateMemberBankDepositForStateRequest.AsObject;
static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
static serializeBinaryToWriter(message: UpdateMemberBankDepositForStateRequest, writer: jspb.BinaryWriter): void;
static deserializeBinary(bytes: Uint8Array): UpdateMemberBankDepositForStateRequest;
static deserializeBinaryFromReader(message: UpdateMemberBankDepositForStateRequest, reader: jspb.BinaryReader): UpdateMemberBankDepositForStateRequest;
}
export namespace UpdateMemberBankDepositForStateRequest {
export type AsObject = {
id: string,
state: models_member_bank_deposit_pb.MemberBankDepositStateMap[keyof models_member_bank_deposit_pb.MemberBankDepositStateMap],
}
}
export class UpdateMemberBankDepositForStateResponse extends jspb.Message {
hasError(): boolean;
clearError(): void;
getError(): protobuf_rpc_pb.Error | undefined;
setError(value?: protobuf_rpc_pb.Error): void;
hasResult(): boolean;
clearResult(): void;
getResult(): UpdateMemberBankDepositForStateResponse.Result | undefined;
setResult(value?: UpdateMemberBankDepositForStateResponse.Result): void;
serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): UpdateMemberBankDepositForStateResponse.AsObject;
static toObject(includeInstance: boolean, msg: UpdateMemberBankDepositForStateResponse): UpdateMemberBankDepositForStateResponse.AsObject;
static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
static serializeBinaryToWriter(message: UpdateMemberBankDepositForStateResponse, writer: jspb.BinaryWriter): void;
static deserializeBinary(bytes: Uint8Array): UpdateMemberBankDepositForStateResponse;
static deserializeBinaryFromReader(message: UpdateMemberBankDepositForStateResponse, reader: jspb.BinaryReader): UpdateMemberBankDepositForStateResponse;
}
export namespace UpdateMemberBankDepositForStateResponse {
export type AsObject = {
error?: protobuf_rpc_pb.Error.AsObject,
result?: UpdateMemberBankDepositForStateResponse.Result.AsObject,
}
export class Result extends jspb.Message {
hasMemberBankDeposit(): boolean;
clearMemberBankDeposit(): void;
getMemberBankDeposit(): models_member_bank_deposit_pb.MemberBankDeposit | undefined;
setMemberBankDeposit(value?: models_member_bank_deposit_pb.MemberBankDeposit): void;
serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): Result.AsObject;
static toObject(includeInstance: boolean, msg: Result): Result.AsObject;
static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
static serializeBinaryToWriter(message: Result, writer: jspb.BinaryWriter): void;
static deserializeBinary(bytes: Uint8Array): Result;
static deserializeBinaryFromReader(message: Result, reader: jspb.BinaryReader): Result;
}
export namespace Result {
export type AsObject = {
memberBankDeposit?: models_member_bank_deposit_pb.MemberBankDeposit.AsObject,
}
}
}
export class DeleteMemberBankDepositRequest extends jspb.Message {
getId(): string;
setId(value: string): void;
serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): DeleteMemberBankDepositRequest.AsObject;
static toObject(includeInstance: boolean, msg: DeleteMemberBankDepositRequest): DeleteMemberBankDepositRequest.AsObject;
static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
static serializeBinaryToWriter(message: DeleteMemberBankDepositRequest, writer: jspb.BinaryWriter): void;
static deserializeBinary(bytes: Uint8Array): DeleteMemberBankDepositRequest;
static deserializeBinaryFromReader(message: DeleteMemberBankDepositRequest, reader: jspb.BinaryReader): DeleteMemberBankDepositRequest;
}
export namespace DeleteMemberBankDepositRequest {
export type AsObject = {
id: string,
}
}
export class DeleteMemberBankDepositResponse extends jspb.Message {
hasError(): boolean;
clearError(): void;
getError(): protobuf_rpc_pb.Error | undefined;
setError(value?: protobuf_rpc_pb.Error): void;
hasResult(): boolean;
clearResult(): void;
getResult(): DeleteMemberBankDepositResponse.Result | undefined;
setResult(value?: DeleteMemberBankDepositResponse.Result): void;
serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): DeleteMemberBankDepositResponse.AsObject;
static toObject(includeInstance: boolean, msg: DeleteMemberBankDepositResponse): DeleteMemberBankDepositResponse.AsObject;
static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
static serializeBinaryToWriter(message: DeleteMemberBankDepositResponse, writer: jspb.BinaryWriter): void;
static deserializeBinary(bytes: Uint8Array): DeleteMemberBankDepositResponse;
static deserializeBinaryFromReader(message: DeleteMemberBankDepositResponse, reader: jspb.BinaryReader): DeleteMemberBankDepositResponse;
}
export namespace DeleteMemberBankDepositResponse {
export type AsObject = {
error?: protobuf_rpc_pb.Error.AsObject,
result?: DeleteMemberBankDepositResponse.Result.AsObject,
}
export class Result extends jspb.Message {
serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): Result.AsObject;
static toObject(includeInstance: boolean, msg: Result): Result.AsObject;
static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
static serializeBinaryToWriter(message: Result, writer: jspb.BinaryWriter): void;
static deserializeBinary(bytes: Uint8Array): Result;
static deserializeBinaryFromReader(message: Result, reader: jspb.BinaryReader): Result;
}
export namespace Result {
export type AsObject = {
}
}
}

3987
src/app/modules/proto/c2se/member_bank_deposit_pb.js Normal file
View File

File diff suppressed because it is too large Load Diff

546
src/app/modules/proto/c2se/member_bank_withdraw_pb.d.ts vendored Normal file
View File

@ -0,0 +1,546 @@
// package: bet.beteran.c2se.member_bank_withdraw
// file: c2se/member_bank_withdraw.proto
import * as jspb from "google-protobuf";
import * as protobuf_rpc_pb from "../protobuf/rpc_pb";
import * as protobuf_pagination_pb from "../protobuf/pagination_pb";
import * as models_member_bank_withdraw_pb from "../models/member_bank_withdraw_pb";
export class CreateMemberBankWithdrawRequest extends jspb.Message {
getBankName(): string;
setBankName(value: string): void;
getName(): string;
setName(value: string): void;
getAccountNumber(): string;
setAccountNumber(value: string): void;
getAmount(): number;
setAmount(value: number): void;
getPassword(): string;
setPassword(value: string): void;
hasMemo(): boolean;
clearMemo(): void;
getMemo(): string;
setMemo(value: string): void;
serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): CreateMemberBankWithdrawRequest.AsObject;
static toObject(includeInstance: boolean, msg: CreateMemberBankWithdrawRequest): CreateMemberBankWithdrawRequest.AsObject;
static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
static serializeBinaryToWriter(message: CreateMemberBankWithdrawRequest, writer: jspb.BinaryWriter): void;
static deserializeBinary(bytes: Uint8Array): CreateMemberBankWithdrawRequest;
static deserializeBinaryFromReader(message: CreateMemberBankWithdrawRequest, reader: jspb.BinaryReader): CreateMemberBankWithdrawRequest;
}
export namespace CreateMemberBankWithdrawRequest {
export type AsObject = {
bankName: string,
name: string,
accountNumber: string,
amount: number,
password: string,
memo: string,
}
}
export class CreateMemberBankWithdrawResponse extends jspb.Message {
hasError(): boolean;
clearError(): void;
getError(): protobuf_rpc_pb.Error | undefined;
setError(value?: protobuf_rpc_pb.Error): void;
hasResult(): boolean;
clearResult(): void;
getResult(): CreateMemberBankWithdrawResponse.Result | undefined;
setResult(value?: CreateMemberBankWithdrawResponse.Result): void;
serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): CreateMemberBankWithdrawResponse.AsObject;
static toObject(includeInstance: boolean, msg: CreateMemberBankWithdrawResponse): CreateMemberBankWithdrawResponse.AsObject;
static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
static serializeBinaryToWriter(message: CreateMemberBankWithdrawResponse, writer: jspb.BinaryWriter): void;
static deserializeBinary(bytes: Uint8Array): CreateMemberBankWithdrawResponse;
static deserializeBinaryFromReader(message: CreateMemberBankWithdrawResponse, reader: jspb.BinaryReader): CreateMemberBankWithdrawResponse;
}
export namespace CreateMemberBankWithdrawResponse {
export type AsObject = {
error?: protobuf_rpc_pb.Error.AsObject,
result?: CreateMemberBankWithdrawResponse.Result.AsObject,
}
export class Result extends jspb.Message {
hasMemberBankWithdraw(): boolean;
clearMemberBankWithdraw(): void;
getMemberBankWithdraw(): models_member_bank_withdraw_pb.MemberBankWithdraw | undefined;
setMemberBankWithdraw(value?: models_member_bank_withdraw_pb.MemberBankWithdraw): void;
serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): Result.AsObject;
static toObject(includeInstance: boolean, msg: Result): Result.AsObject;
static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
static serializeBinaryToWriter(message: Result, writer: jspb.BinaryWriter): void;
static deserializeBinary(bytes: Uint8Array): Result;
static deserializeBinaryFromReader(message: Result, reader: jspb.BinaryReader): Result;
}
export namespace Result {
export type AsObject = {
memberBankWithdraw?: models_member_bank_withdraw_pb.MemberBankWithdraw.AsObject,
}
}
}
export class ListMemberBankWithdrawsRequest extends jspb.Message {
hasPagination(): boolean;
clearPagination(): void;
getPagination(): protobuf_pagination_pb.Pagination | undefined;
setPagination(value?: protobuf_pagination_pb.Pagination): void;
clearSortsList(): void;
getSortsList(): Array<protobuf_pagination_pb.Sort>;
setSortsList(value: Array<protobuf_pagination_pb.Sort>): void;
addSorts(value?: protobuf_pagination_pb.Sort, index?: number): protobuf_pagination_pb.Sort;
hasSearch(): boolean;
clearSearch(): void;
getSearch(): ListMemberBankWithdrawsRequest.Search | undefined;
setSearch(value?: ListMemberBankWithdrawsRequest.Search): void;
serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): ListMemberBankWithdrawsRequest.AsObject;
static toObject(includeInstance: boolean, msg: ListMemberBankWithdrawsRequest): ListMemberBankWithdrawsRequest.AsObject;
static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
static serializeBinaryToWriter(message: ListMemberBankWithdrawsRequest, writer: jspb.BinaryWriter): void;
static deserializeBinary(bytes: Uint8Array): ListMemberBankWithdrawsRequest;
static deserializeBinaryFromReader(message: ListMemberBankWithdrawsRequest, reader: jspb.BinaryReader): ListMemberBankWithdrawsRequest;
}
export namespace ListMemberBankWithdrawsRequest {
export type AsObject = {
pagination?: protobuf_pagination_pb.Pagination.AsObject,
sortsList: Array<protobuf_pagination_pb.Sort.AsObject>,
search?: ListMemberBankWithdrawsRequest.Search.AsObject,
}
export class Search extends jspb.Message {
hasMemberId(): boolean;
clearMemberId(): void;
getMemberId(): string;
setMemberId(value: string): void;
hasBankNameLike(): boolean;
clearBankNameLike(): void;
getBankNameLike(): string;
setBankNameLike(value: string): void;
hasNameLike(): boolean;
clearNameLike(): void;
getNameLike(): string;
setNameLike(value: string): void;
hasAccountNumberLike(): boolean;
clearAccountNumberLike(): void;
getAccountNumberLike(): string;
setAccountNumberLike(value: string): void;
hasAmount(): boolean;
clearAmount(): void;
getAmount(): number;
setAmount(value: number): void;
hasMemoLike(): boolean;
clearMemoLike(): void;
getMemoLike(): string;
setMemoLike(value: string): void;
hasState(): boolean;
clearState(): void;
getState(): models_member_bank_withdraw_pb.MemberBankWithdrawStateMap[keyof models_member_bank_withdraw_pb.MemberBankWithdrawStateMap];
setState(value: models_member_bank_withdraw_pb.MemberBankWithdrawStateMap[keyof models_member_bank_withdraw_pb.MemberBankWithdrawStateMap]): void;
serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): Search.AsObject;
static toObject(includeInstance: boolean, msg: Search): Search.AsObject;
static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
static serializeBinaryToWriter(message: Search, writer: jspb.BinaryWriter): void;
static deserializeBinary(bytes: Uint8Array): Search;
static deserializeBinaryFromReader(message: Search, reader: jspb.BinaryReader): Search;
}
export namespace Search {
export type AsObject = {
memberId: string,
bankNameLike: string,
nameLike: string,
accountNumberLike: string,
amount: number,
memoLike: string,
state: models_member_bank_withdraw_pb.MemberBankWithdrawStateMap[keyof models_member_bank_withdraw_pb.MemberBankWithdrawStateMap],
}
}
}
export class ListMemberBankWithdrawsResponse extends jspb.Message {
hasError(): boolean;
clearError(): void;
getError(): protobuf_rpc_pb.Error | undefined;
setError(value?: protobuf_rpc_pb.Error): void;
hasResult(): boolean;
clearResult(): void;
getResult(): ListMemberBankWithdrawsResponse.Result | undefined;
setResult(value?: ListMemberBankWithdrawsResponse.Result): void;
serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): ListMemberBankWithdrawsResponse.AsObject;
static toObject(includeInstance: boolean, msg: ListMemberBankWithdrawsResponse): ListMemberBankWithdrawsResponse.AsObject;
static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
static serializeBinaryToWriter(message: ListMemberBankWithdrawsResponse, writer: jspb.BinaryWriter): void;
static deserializeBinary(bytes: Uint8Array): ListMemberBankWithdrawsResponse;
static deserializeBinaryFromReader(message: ListMemberBankWithdrawsResponse, reader: jspb.BinaryReader): ListMemberBankWithdrawsResponse;
}
export namespace ListMemberBankWithdrawsResponse {
export type AsObject = {
error?: protobuf_rpc_pb.Error.AsObject,
result?: ListMemberBankWithdrawsResponse.Result.AsObject,
}
export class Result extends jspb.Message {
clearMemberBankWithdrawsList(): void;
getMemberBankWithdrawsList(): Array<models_member_bank_withdraw_pb.MemberBankWithdraw>;
setMemberBankWithdrawsList(value: Array<models_member_bank_withdraw_pb.MemberBankWithdraw>): void;
addMemberBankWithdraws(value?: models_member_bank_withdraw_pb.MemberBankWithdraw, index?: number): models_member_bank_withdraw_pb.MemberBankWithdraw;
serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): Result.AsObject;
static toObject(includeInstance: boolean, msg: Result): Result.AsObject;
static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
static serializeBinaryToWriter(message: Result, writer: jspb.BinaryWriter): void;
static deserializeBinary(bytes: Uint8Array): Result;
static deserializeBinaryFromReader(message: Result, reader: jspb.BinaryReader): Result;
}
export namespace Result {
export type AsObject = {
memberBankWithdrawsList: Array<models_member_bank_withdraw_pb.MemberBankWithdraw.AsObject>,
}
}
}
export class GetMemberBankWithdrawRequest extends jspb.Message {
getId(): string;
setId(value: string): void;
serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): GetMemberBankWithdrawRequest.AsObject;
static toObject(includeInstance: boolean, msg: GetMemberBankWithdrawRequest): GetMemberBankWithdrawRequest.AsObject;
static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
static serializeBinaryToWriter(message: GetMemberBankWithdrawRequest, writer: jspb.BinaryWriter): void;
static deserializeBinary(bytes: Uint8Array): GetMemberBankWithdrawRequest;
static deserializeBinaryFromReader(message: GetMemberBankWithdrawRequest, reader: jspb.BinaryReader): GetMemberBankWithdrawRequest;
}
export namespace GetMemberBankWithdrawRequest {
export type AsObject = {
id: string,
}
}
export class GetMemberBankWithdrawResponse extends jspb.Message {
hasError(): boolean;
clearError(): void;
getError(): protobuf_rpc_pb.Error | undefined;
setError(value?: protobuf_rpc_pb.Error): void;
hasResult(): boolean;
clearResult(): void;
getResult(): GetMemberBankWithdrawResponse.Result | undefined;
setResult(value?: GetMemberBankWithdrawResponse.Result): void;
serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): GetMemberBankWithdrawResponse.AsObject;
static toObject(includeInstance: boolean, msg: GetMemberBankWithdrawResponse): GetMemberBankWithdrawResponse.AsObject;
static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
static serializeBinaryToWriter(message: GetMemberBankWithdrawResponse, writer: jspb.BinaryWriter): void;
static deserializeBinary(bytes: Uint8Array): GetMemberBankWithdrawResponse;
static deserializeBinaryFromReader(message: GetMemberBankWithdrawResponse, reader: jspb.BinaryReader): GetMemberBankWithdrawResponse;
}
export namespace GetMemberBankWithdrawResponse {
export type AsObject = {
error?: protobuf_rpc_pb.Error.AsObject,
result?: GetMemberBankWithdrawResponse.Result.AsObject,
}
export class Result extends jspb.Message {
hasMemberBankWithdraw(): boolean;
clearMemberBankWithdraw(): void;
getMemberBankWithdraw(): models_member_bank_withdraw_pb.MemberBankWithdraw | undefined;
setMemberBankWithdraw(value?: models_member_bank_withdraw_pb.MemberBankWithdraw): void;
serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): Result.AsObject;
static toObject(includeInstance: boolean, msg: Result): Result.AsObject;
static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
static serializeBinaryToWriter(message: Result, writer: jspb.BinaryWriter): void;
static deserializeBinary(bytes: Uint8Array): Result;
static deserializeBinaryFromReader(message: Result, reader: jspb.BinaryReader): Result;
}
export namespace Result {
export type AsObject = {
memberBankWithdraw?: models_member_bank_withdraw_pb.MemberBankWithdraw.AsObject,
}
}
}
export class UpdateMemberBankWithdrawRequest extends jspb.Message {
getId(): string;
setId(value: string): void;
getBankName(): string;
setBankName(value: string): void;
getName(): string;
setName(value: string): void;
getAccountNumber(): string;
setAccountNumber(value: string): void;
getAmount(): number;
setAmount(value: number): void;
getPassword(): string;
setPassword(value: string): void;
hasMemo(): boolean;
clearMemo(): void;
getMemo(): string;
setMemo(value: string): void;
serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): UpdateMemberBankWithdrawRequest.AsObject;
static toObject(includeInstance: boolean, msg: UpdateMemberBankWithdrawRequest): UpdateMemberBankWithdrawRequest.AsObject;
static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
static serializeBinaryToWriter(message: UpdateMemberBankWithdrawRequest, writer: jspb.BinaryWriter): void;
static deserializeBinary(bytes: Uint8Array): UpdateMemberBankWithdrawRequest;
static deserializeBinaryFromReader(message: UpdateMemberBankWithdrawRequest, reader: jspb.BinaryReader): UpdateMemberBankWithdrawRequest;
}
export namespace UpdateMemberBankWithdrawRequest {
export type AsObject = {
id: string,
bankName: string,
name: string,
accountNumber: string,
amount: number,
password: string,
memo: string,
}
}
export class UpdateMemberBankWithdrawResponse extends jspb.Message {
hasError(): boolean;
clearError(): void;
getError(): protobuf_rpc_pb.Error | undefined;
setError(value?: protobuf_rpc_pb.Error): void;
hasResult(): boolean;
clearResult(): void;
getResult(): UpdateMemberBankWithdrawResponse.Result | undefined;
setResult(value?: UpdateMemberBankWithdrawResponse.Result): void;
serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): UpdateMemberBankWithdrawResponse.AsObject;
static toObject(includeInstance: boolean, msg: UpdateMemberBankWithdrawResponse): UpdateMemberBankWithdrawResponse.AsObject;
static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
static serializeBinaryToWriter(message: UpdateMemberBankWithdrawResponse, writer: jspb.BinaryWriter): void;
static deserializeBinary(bytes: Uint8Array): UpdateMemberBankWithdrawResponse;
static deserializeBinaryFromReader(message: UpdateMemberBankWithdrawResponse, reader: jspb.BinaryReader): UpdateMemberBankWithdrawResponse;
}
export namespace UpdateMemberBankWithdrawResponse {
export type AsObject = {
error?: protobuf_rpc_pb.Error.AsObject,
result?: UpdateMemberBankWithdrawResponse.Result.AsObject,
}
export class Result extends jspb.Message {
hasMemberBankWithdraw(): boolean;
clearMemberBankWithdraw(): void;
getMemberBankWithdraw(): models_member_bank_withdraw_pb.MemberBankWithdraw | undefined;
setMemberBankWithdraw(value?: models_member_bank_withdraw_pb.MemberBankWithdraw): void;
serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): Result.AsObject;
static toObject(includeInstance: boolean, msg: Result): Result.AsObject;
static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
static serializeBinaryToWriter(message: Result, writer: jspb.BinaryWriter): void;
static deserializeBinary(bytes: Uint8Array): Result;
static deserializeBinaryFromReader(message: Result, reader: jspb.BinaryReader): Result;
}
export namespace Result {
export type AsObject = {
memberBankWithdraw?: models_member_bank_withdraw_pb.MemberBankWithdraw.AsObject,
}
}
}
export class UpdateMemberBankWithdrawForStateRequest extends jspb.Message {
getId(): string;
setId(value: string): void;
getState(): models_member_bank_withdraw_pb.MemberBankWithdrawStateMap[keyof models_member_bank_withdraw_pb.MemberBankWithdrawStateMap];
setState(value: models_member_bank_withdraw_pb.MemberBankWithdrawStateMap[keyof models_member_bank_withdraw_pb.MemberBankWithdrawStateMap]): void;
serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): UpdateMemberBankWithdrawForStateRequest.AsObject;
static toObject(includeInstance: boolean, msg: UpdateMemberBankWithdrawForStateRequest): UpdateMemberBankWithdrawForStateRequest.AsObject;
static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
static serializeBinaryToWriter(message: UpdateMemberBankWithdrawForStateRequest, writer: jspb.BinaryWriter): void;
static deserializeBinary(bytes: Uint8Array): UpdateMemberBankWithdrawForStateRequest;
static deserializeBinaryFromReader(message: UpdateMemberBankWithdrawForStateRequest, reader: jspb.BinaryReader): UpdateMemberBankWithdrawForStateRequest;
}
export namespace UpdateMemberBankWithdrawForStateRequest {
export type AsObject = {
id: string,
state: models_member_bank_withdraw_pb.MemberBankWithdrawStateMap[keyof models_member_bank_withdraw_pb.MemberBankWithdrawStateMap],
}
}
export class UpdateMemberBankWithdrawForStateResponse extends jspb.Message {
hasError(): boolean;
clearError(): void;
getError(): protobuf_rpc_pb.Error | undefined;
setError(value?: protobuf_rpc_pb.Error): void;
hasResult(): boolean;
clearResult(): void;
getResult(): UpdateMemberBankWithdrawForStateResponse.Result | undefined;
setResult(value?: UpdateMemberBankWithdrawForStateResponse.Result): void;
serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): UpdateMemberBankWithdrawForStateResponse.AsObject;
static toObject(includeInstance: boolean, msg: UpdateMemberBankWithdrawForStateResponse): UpdateMemberBankWithdrawForStateResponse.AsObject;
static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
static serializeBinaryToWriter(message: UpdateMemberBankWithdrawForStateResponse, writer: jspb.BinaryWriter): void;
static deserializeBinary(bytes: Uint8Array): UpdateMemberBankWithdrawForStateResponse;
static deserializeBinaryFromReader(message: UpdateMemberBankWithdrawForStateResponse, reader: jspb.BinaryReader): UpdateMemberBankWithdrawForStateResponse;
}
export namespace UpdateMemberBankWithdrawForStateResponse {
export type AsObject = {
error?: protobuf_rpc_pb.Error.AsObject,
result?: UpdateMemberBankWithdrawForStateResponse.Result.AsObject,
}
export class Result extends jspb.Message {
hasMemberBankWithdraw(): boolean;
clearMemberBankWithdraw(): void;
getMemberBankWithdraw(): models_member_bank_withdraw_pb.MemberBankWithdraw | undefined;
setMemberBankWithdraw(value?: models_member_bank_withdraw_pb.MemberBankWithdraw): void;
serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): Result.AsObject;
static toObject(includeInstance: boolean, msg: Result): Result.AsObject;
static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
static serializeBinaryToWriter(message: Result, writer: jspb.BinaryWriter): void;
static deserializeBinary(bytes: Uint8Array): Result;
static deserializeBinaryFromReader(message: Result, reader: jspb.BinaryReader): Result;
}
export namespace Result {
export type AsObject = {
memberBankWithdraw?: models_member_bank_withdraw_pb.MemberBankWithdraw.AsObject,
}
}
}
export class DeleteMemberBankWithdrawRequest extends jspb.Message {
getId(): string;
setId(value: string): void;
serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): DeleteMemberBankWithdrawRequest.AsObject;
static toObject(includeInstance: boolean, msg: DeleteMemberBankWithdrawRequest): DeleteMemberBankWithdrawRequest.AsObject;
static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
static serializeBinaryToWriter(message: DeleteMemberBankWithdrawRequest, writer: jspb.BinaryWriter): void;
static deserializeBinary(bytes: Uint8Array): DeleteMemberBankWithdrawRequest;
static deserializeBinaryFromReader(message: DeleteMemberBankWithdrawRequest, reader: jspb.BinaryReader): DeleteMemberBankWithdrawRequest;
}
export namespace DeleteMemberBankWithdrawRequest {
export type AsObject = {
id: string,
}
}
export class DeleteMemberBankWithdrawResponse extends jspb.Message {
hasError(): boolean;
clearError(): void;
getError(): protobuf_rpc_pb.Error | undefined;
setError(value?: protobuf_rpc_pb.Error): void;
hasResult(): boolean;
clearResult(): void;
getResult(): DeleteMemberBankWithdrawResponse.Result | undefined;
setResult(value?: DeleteMemberBankWithdrawResponse.Result): void;
serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): DeleteMemberBankWithdrawResponse.AsObject;
static toObject(includeInstance: boolean, msg: DeleteMemberBankWithdrawResponse): DeleteMemberBankWithdrawResponse.AsObject;
static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
static serializeBinaryToWriter(message: DeleteMemberBankWithdrawResponse, writer: jspb.BinaryWriter): void;
static deserializeBinary(bytes: Uint8Array): DeleteMemberBankWithdrawResponse;
static deserializeBinaryFromReader(message: DeleteMemberBankWithdrawResponse, reader: jspb.BinaryReader): DeleteMemberBankWithdrawResponse;
}
export namespace DeleteMemberBankWithdrawResponse {
export type AsObject = {
error?: protobuf_rpc_pb.Error.AsObject,
result?: DeleteMemberBankWithdrawResponse.Result.AsObject,
}
export class Result extends jspb.Message {
serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): Result.AsObject;
static toObject(includeInstance: boolean, msg: Result): Result.AsObject;
static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
static serializeBinaryToWriter(message: Result, writer: jspb.BinaryWriter): void;
static deserializeBinary(bytes: Uint8Array): Result;
static deserializeBinaryFromReader(message: Result, reader: jspb.BinaryReader): Result;
}
export namespace Result {
export type AsObject = {
}
}
}

4263
src/app/modules/proto/c2se/member_bank_withdraw_pb.js Normal file
View File

File diff suppressed because it is too large Load Diff

418
src/app/modules/proto/c2se/member_class_pb.d.ts vendored Normal file
View File

@ -0,0 +1,418 @@
// package: bet.beteran.c2se.member_class
// file: c2se/member_class.proto
import * as jspb from "google-protobuf";
import * as protobuf_rpc_pb from "../protobuf/rpc_pb";
import * as protobuf_pagination_pb from "../protobuf/pagination_pb";
import * as models_member_class_pb from "../models/member_class_pb";
export class CreateMemberClassRequest extends jspb.Message {
hasParentId(): boolean;
clearParentId(): void;
getParentId(): string;
setParentId(value: string): void;
getName(): string;
setName(value: string): void;
getShow(): boolean;
setShow(value: boolean): void;
serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): CreateMemberClassRequest.AsObject;
static toObject(includeInstance: boolean, msg: CreateMemberClassRequest): CreateMemberClassRequest.AsObject;
static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
static serializeBinaryToWriter(message: CreateMemberClassRequest, writer: jspb.BinaryWriter): void;
static deserializeBinary(bytes: Uint8Array): CreateMemberClassRequest;
static deserializeBinaryFromReader(message: CreateMemberClassRequest, reader: jspb.BinaryReader): CreateMemberClassRequest;
}
export namespace CreateMemberClassRequest {
export type AsObject = {
parentId: string,
name: string,
show: boolean,
}
}
export class CreateMemberClassResponse extends jspb.Message {
hasError(): boolean;
clearError(): void;
getError(): protobuf_rpc_pb.Error | undefined;
setError(value?: protobuf_rpc_pb.Error): void;
hasResult(): boolean;
clearResult(): void;
getResult(): CreateMemberClassResponse.Result | undefined;
setResult(value?: CreateMemberClassResponse.Result): void;
serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): CreateMemberClassResponse.AsObject;
static toObject(includeInstance: boolean, msg: CreateMemberClassResponse): CreateMemberClassResponse.AsObject;
static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
static serializeBinaryToWriter(message: CreateMemberClassResponse, writer: jspb.BinaryWriter): void;
static deserializeBinary(bytes: Uint8Array): CreateMemberClassResponse;
static deserializeBinaryFromReader(message: CreateMemberClassResponse, reader: jspb.BinaryReader): CreateMemberClassResponse;
}
export namespace CreateMemberClassResponse {
export type AsObject = {
error?: protobuf_rpc_pb.Error.AsObject,
result?: CreateMemberClassResponse.Result.AsObject,
}
export class Result extends jspb.Message {
hasMemberClass(): boolean;
clearMemberClass(): void;
getMemberClass(): models_member_class_pb.MemberClass | undefined;
setMemberClass(value?: models_member_class_pb.MemberClass): void;
serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): Result.AsObject;
static toObject(includeInstance: boolean, msg: Result): Result.AsObject;
static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
static serializeBinaryToWriter(message: Result, writer: jspb.BinaryWriter): void;
static deserializeBinary(bytes: Uint8Array): Result;
static deserializeBinaryFromReader(message: Result, reader: jspb.BinaryReader): Result;
}
export namespace Result {
export type AsObject = {
memberClass?: models_member_class_pb.MemberClass.AsObject,
}
}
}
export class ListMemberClassesRequest extends jspb.Message {
hasPagination(): boolean;
clearPagination(): void;
getPagination(): protobuf_pagination_pb.Pagination | undefined;
setPagination(value?: protobuf_pagination_pb.Pagination): void;
clearSortsList(): void;
getSortsList(): Array<protobuf_pagination_pb.Sort>;
setSortsList(value: Array<protobuf_pagination_pb.Sort>): void;
addSorts(value?: protobuf_pagination_pb.Sort, index?: number): protobuf_pagination_pb.Sort;
hasSearch(): boolean;
clearSearch(): void;
getSearch(): ListMemberClassesRequest.Search | undefined;
setSearch(value?: ListMemberClassesRequest.Search): void;
serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): ListMemberClassesRequest.AsObject;
static toObject(includeInstance: boolean, msg: ListMemberClassesRequest): ListMemberClassesRequest.AsObject;
static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
static serializeBinaryToWriter(message: ListMemberClassesRequest, writer: jspb.BinaryWriter): void;
static deserializeBinary(bytes: Uint8Array): ListMemberClassesRequest;
static deserializeBinaryFromReader(message: ListMemberClassesRequest, reader: jspb.BinaryReader): ListMemberClassesRequest;
}
export namespace ListMemberClassesRequest {
export type AsObject = {
pagination?: protobuf_pagination_pb.Pagination.AsObject,
sortsList: Array<protobuf_pagination_pb.Sort.AsObject>,
search?: ListMemberClassesRequest.Search.AsObject,
}
export class Search extends jspb.Message {
hasNameLike(): boolean;
clearNameLike(): void;
getNameLike(): string;
setNameLike(value: string): void;
hasShow(): boolean;
clearShow(): void;
getShow(): boolean;
setShow(value: boolean): void;
serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): Search.AsObject;
static toObject(includeInstance: boolean, msg: Search): Search.AsObject;
static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
static serializeBinaryToWriter(message: Search, writer: jspb.BinaryWriter): void;
static deserializeBinary(bytes: Uint8Array): Search;
static deserializeBinaryFromReader(message: Search, reader: jspb.BinaryReader): Search;
}
export namespace Search {
export type AsObject = {
nameLike: string,
show: boolean,
}
}
}
export class ListMemberClassesResponse extends jspb.Message {
hasError(): boolean;
clearError(): void;
getError(): protobuf_rpc_pb.Error | undefined;
setError(value?: protobuf_rpc_pb.Error): void;
hasResult(): boolean;
clearResult(): void;
getResult(): ListMemberClassesResponse.Result | undefined;
setResult(value?: ListMemberClassesResponse.Result): void;
serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): ListMemberClassesResponse.AsObject;
static toObject(includeInstance: boolean, msg: ListMemberClassesResponse): ListMemberClassesResponse.AsObject;
static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
static serializeBinaryToWriter(message: ListMemberClassesResponse, writer: jspb.BinaryWriter): void;
static deserializeBinary(bytes: Uint8Array): ListMemberClassesResponse;
static deserializeBinaryFromReader(message: ListMemberClassesResponse, reader: jspb.BinaryReader): ListMemberClassesResponse;
}
export namespace ListMemberClassesResponse {
export type AsObject = {
error?: protobuf_rpc_pb.Error.AsObject,
result?: ListMemberClassesResponse.Result.AsObject,
}
export class Result extends jspb.Message {
clearMemberClassesList(): void;
getMemberClassesList(): Array<models_member_class_pb.MemberClass>;
setMemberClassesList(value: Array<models_member_class_pb.MemberClass>): void;
addMemberClasses(value?: models_member_class_pb.MemberClass, index?: number): models_member_class_pb.MemberClass;
serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): Result.AsObject;
static toObject(includeInstance: boolean, msg: Result): Result.AsObject;
static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
static serializeBinaryToWriter(message: Result, writer: jspb.BinaryWriter): void;
static deserializeBinary(bytes: Uint8Array): Result;
static deserializeBinaryFromReader(message: Result, reader: jspb.BinaryReader): Result;
}
export namespace Result {
export type AsObject = {
memberClassesList: Array<models_member_class_pb.MemberClass.AsObject>,
}
}
}
export class GetMemberClassRequest extends jspb.Message {
getId(): string;
setId(value: string): void;
serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): GetMemberClassRequest.AsObject;
static toObject(includeInstance: boolean, msg: GetMemberClassRequest): GetMemberClassRequest.AsObject;
static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
static serializeBinaryToWriter(message: GetMemberClassRequest, writer: jspb.BinaryWriter): void;
static deserializeBinary(bytes: Uint8Array): GetMemberClassRequest;
static deserializeBinaryFromReader(message: GetMemberClassRequest, reader: jspb.BinaryReader): GetMemberClassRequest;
}
export namespace GetMemberClassRequest {
export type AsObject = {
id: string,
}
}
export class GetMemberClassResponse extends jspb.Message {
hasError(): boolean;
clearError(): void;
getError(): protobuf_rpc_pb.Error | undefined;
setError(value?: protobuf_rpc_pb.Error): void;
hasResult(): boolean;
clearResult(): void;
getResult(): GetMemberClassResponse.Result | undefined;
setResult(value?: GetMemberClassResponse.Result): void;
serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): GetMemberClassResponse.AsObject;
static toObject(includeInstance: boolean, msg: GetMemberClassResponse): GetMemberClassResponse.AsObject;
static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
static serializeBinaryToWriter(message: GetMemberClassResponse, writer: jspb.BinaryWriter): void;
static deserializeBinary(bytes: Uint8Array): GetMemberClassResponse;
static deserializeBinaryFromReader(message: GetMemberClassResponse, reader: jspb.BinaryReader): GetMemberClassResponse;
}
export namespace GetMemberClassResponse {
export type AsObject = {
error?: protobuf_rpc_pb.Error.AsObject,
result?: GetMemberClassResponse.Result.AsObject,
}
export class Result extends jspb.Message {
hasMemberClass(): boolean;
clearMemberClass(): void;
getMemberClass(): models_member_class_pb.MemberClass | undefined;
setMemberClass(value?: models_member_class_pb.MemberClass): void;
serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): Result.AsObject;
static toObject(includeInstance: boolean, msg: Result): Result.AsObject;
static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
static serializeBinaryToWriter(message: Result, writer: jspb.BinaryWriter): void;
static deserializeBinary(bytes: Uint8Array): Result;
static deserializeBinaryFromReader(message: Result, reader: jspb.BinaryReader): Result;
}
export namespace Result {
export type AsObject = {
memberClass?: models_member_class_pb.MemberClass.AsObject,
}
}
}
export class UpdateMemberClassRequest extends jspb.Message {
getId(): string;
setId(value: string): void;
hasParentId(): boolean;
clearParentId(): void;
getParentId(): string;
setParentId(value: string): void;
getName(): string;
setName(value: string): void;
getShow(): boolean;
setShow(value: boolean): void;
serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): UpdateMemberClassRequest.AsObject;
static toObject(includeInstance: boolean, msg: UpdateMemberClassRequest): UpdateMemberClassRequest.AsObject;
static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
static serializeBinaryToWriter(message: UpdateMemberClassRequest, writer: jspb.BinaryWriter): void;
static deserializeBinary(bytes: Uint8Array): UpdateMemberClassRequest;
static deserializeBinaryFromReader(message: UpdateMemberClassRequest, reader: jspb.BinaryReader): UpdateMemberClassRequest;
}
export namespace UpdateMemberClassRequest {
export type AsObject = {
id: string,
parentId: string,
name: string,
show: boolean,
}
}
export class UpdateMemberClassResponse extends jspb.Message {
hasError(): boolean;
clearError(): void;
getError(): protobuf_rpc_pb.Error | undefined;
setError(value?: protobuf_rpc_pb.Error): void;
hasResult(): boolean;
clearResult(): void;
getResult(): UpdateMemberClassResponse.Result | undefined;
setResult(value?: UpdateMemberClassResponse.Result): void;
serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): UpdateMemberClassResponse.AsObject;
static toObject(includeInstance: boolean, msg: UpdateMemberClassResponse): UpdateMemberClassResponse.AsObject;
static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
static serializeBinaryToWriter(message: UpdateMemberClassResponse, writer: jspb.BinaryWriter): void;
static deserializeBinary(bytes: Uint8Array): UpdateMemberClassResponse;
static deserializeBinaryFromReader(message: UpdateMemberClassResponse, reader: jspb.BinaryReader): UpdateMemberClassResponse;
}
export namespace UpdateMemberClassResponse {
export type AsObject = {
error?: protobuf_rpc_pb.Error.AsObject,
result?: UpdateMemberClassResponse.Result.AsObject,
}
export class Result extends jspb.Message {
hasMemberClass(): boolean;
clearMemberClass(): void;
getMemberClass(): models_member_class_pb.MemberClass | undefined;
setMemberClass(value?: models_member_class_pb.MemberClass): void;
serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): Result.AsObject;
static toObject(includeInstance: boolean, msg: Result): Result.AsObject;
static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
static serializeBinaryToWriter(message: Result, writer: jspb.BinaryWriter): void;
static deserializeBinary(bytes: Uint8Array): Result;
static deserializeBinaryFromReader(message: Result, reader: jspb.BinaryReader): Result;
}
export namespace Result {
export type AsObject = {
memberClass?: models_member_class_pb.MemberClass.AsObject,
}
}
}
export class DeleteMemberClassRequest extends jspb.Message {
getId(): string;
setId(value: string): void;
serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): DeleteMemberClassRequest.AsObject;
static toObject(includeInstance: boolean, msg: DeleteMemberClassRequest): DeleteMemberClassRequest.AsObject;
static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
static serializeBinaryToWriter(message: DeleteMemberClassRequest, writer: jspb.BinaryWriter): void;
static deserializeBinary(bytes: Uint8Array): DeleteMemberClassRequest;
static deserializeBinaryFromReader(message: DeleteMemberClassRequest, reader: jspb.BinaryReader): DeleteMemberClassRequest;
}
export namespace DeleteMemberClassRequest {
export type AsObject = {
id: string,
}
}
export class DeleteMemberClassResponse extends jspb.Message {
hasError(): boolean;
clearError(): void;
getError(): protobuf_rpc_pb.Error | undefined;
setError(value?: protobuf_rpc_pb.Error): void;
hasResult(): boolean;
clearResult(): void;
getResult(): DeleteMemberClassResponse.Result | undefined;
setResult(value?: DeleteMemberClassResponse.Result): void;
serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): DeleteMemberClassResponse.AsObject;
static toObject(includeInstance: boolean, msg: DeleteMemberClassResponse): DeleteMemberClassResponse.AsObject;
static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
static serializeBinaryToWriter(message: DeleteMemberClassResponse, writer: jspb.BinaryWriter): void;
static deserializeBinary(bytes: Uint8Array): DeleteMemberClassResponse;
static deserializeBinaryFromReader(message: DeleteMemberClassResponse, reader: jspb.BinaryReader): DeleteMemberClassResponse;
}
export namespace DeleteMemberClassResponse {
export type AsObject = {
error?: protobuf_rpc_pb.Error.AsObject,
result?: DeleteMemberClassResponse.Result.AsObject,
}
export class Result extends jspb.Message {
serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): Result.AsObject;
static toObject(includeInstance: boolean, msg: Result): Result.AsObject;
static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
static serializeBinaryToWriter(message: Result, writer: jspb.BinaryWriter): void;
static deserializeBinary(bytes: Uint8Array): Result;
static deserializeBinaryFromReader(message: Result, reader: jspb.BinaryReader): Result;
}
export namespace Result {
export type AsObject = {
}
}
}

3264
src/app/modules/proto/c2se/member_class_pb.js Normal file
View File

File diff suppressed because it is too large Load Diff

414
src/app/modules/proto/c2se/member_level_pb.d.ts vendored Normal file
View File

@ -0,0 +1,414 @@
// package: bet.beteran.c2se.member_level
// file: c2se/member_level.proto
import * as jspb from "google-protobuf";
import * as protobuf_rpc_pb from "../protobuf/rpc_pb";
import * as protobuf_pagination_pb from "../protobuf/pagination_pb";
import * as models_member_level_pb from "../models/member_level_pb";
export class CreateMemberLevelRequest extends jspb.Message {
getName(): string;
setName(value: string): void;
getShow(): boolean;
setShow(value: boolean): void;
getSortOrder(): number;
setSortOrder(value: number): void;
serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): CreateMemberLevelRequest.AsObject;
static toObject(includeInstance: boolean, msg: CreateMemberLevelRequest): CreateMemberLevelRequest.AsObject;
static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
static serializeBinaryToWriter(message: CreateMemberLevelRequest, writer: jspb.BinaryWriter): void;
static deserializeBinary(bytes: Uint8Array): CreateMemberLevelRequest;
static deserializeBinaryFromReader(message: CreateMemberLevelRequest, reader: jspb.BinaryReader): CreateMemberLevelRequest;
}
export namespace CreateMemberLevelRequest {
export type AsObject = {
name: string,
show: boolean,
sortOrder: number,
}
}
export class CreateMemberLevelResponse extends jspb.Message {
hasError(): boolean;
clearError(): void;
getError(): protobuf_rpc_pb.Error | undefined;
setError(value?: protobuf_rpc_pb.Error): void;
hasResult(): boolean;
clearResult(): void;
getResult(): CreateMemberLevelResponse.Result | undefined;
setResult(value?: CreateMemberLevelResponse.Result): void;
serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): CreateMemberLevelResponse.AsObject;
static toObject(includeInstance: boolean, msg: CreateMemberLevelResponse): CreateMemberLevelResponse.AsObject;
static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
static serializeBinaryToWriter(message: CreateMemberLevelResponse, writer: jspb.BinaryWriter): void;
static deserializeBinary(bytes: Uint8Array): CreateMemberLevelResponse;
static deserializeBinaryFromReader(message: CreateMemberLevelResponse, reader: jspb.BinaryReader): CreateMemberLevelResponse;
}
export namespace CreateMemberLevelResponse {
export type AsObject = {
error?: protobuf_rpc_pb.Error.AsObject,
result?: CreateMemberLevelResponse.Result.AsObject,
}
export class Result extends jspb.Message {
hasMemberLevel(): boolean;
clearMemberLevel(): void;
getMemberLevel(): models_member_level_pb.MemberLevel | undefined;
setMemberLevel(value?: models_member_level_pb.MemberLevel): void;
serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): Result.AsObject;
static toObject(includeInstance: boolean, msg: Result): Result.AsObject;
static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
static serializeBinaryToWriter(message: Result, writer: jspb.BinaryWriter): void;
static deserializeBinary(bytes: Uint8Array): Result;
static deserializeBinaryFromReader(message: Result, reader: jspb.BinaryReader): Result;
}
export namespace Result {
export type AsObject = {
memberLevel?: models_member_level_pb.MemberLevel.AsObject,
}
}
}
export class ListMemberLevelsRequest extends jspb.Message {
hasPagination(): boolean;
clearPagination(): void;
getPagination(): protobuf_pagination_pb.Pagination | undefined;
setPagination(value?: protobuf_pagination_pb.Pagination): void;
clearSortsList(): void;
getSortsList(): Array<protobuf_pagination_pb.Sort>;
setSortsList(value: Array<protobuf_pagination_pb.Sort>): void;
addSorts(value?: protobuf_pagination_pb.Sort, index?: number): protobuf_pagination_pb.Sort;
hasSearch(): boolean;
clearSearch(): void;
getSearch(): ListMemberLevelsRequest.Search | undefined;
setSearch(value?: ListMemberLevelsRequest.Search): void;
serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): ListMemberLevelsRequest.AsObject;
static toObject(includeInstance: boolean, msg: ListMemberLevelsRequest): ListMemberLevelsRequest.AsObject;
static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
static serializeBinaryToWriter(message: ListMemberLevelsRequest, writer: jspb.BinaryWriter): void;
static deserializeBinary(bytes: Uint8Array): ListMemberLevelsRequest;
static deserializeBinaryFromReader(message: ListMemberLevelsRequest, reader: jspb.BinaryReader): ListMemberLevelsRequest;
}
export namespace ListMemberLevelsRequest {
export type AsObject = {
pagination?: protobuf_pagination_pb.Pagination.AsObject,
sortsList: Array<protobuf_pagination_pb.Sort.AsObject>,
search?: ListMemberLevelsRequest.Search.AsObject,
}
export class Search extends jspb.Message {
hasNameLike(): boolean;
clearNameLike(): void;
getNameLike(): string;
setNameLike(value: string): void;
hasShow(): boolean;
clearShow(): void;
getShow(): boolean;
setShow(value: boolean): void;
serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): Search.AsObject;
static toObject(includeInstance: boolean, msg: Search): Search.AsObject;
static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
static serializeBinaryToWriter(message: Search, writer: jspb.BinaryWriter): void;
static deserializeBinary(bytes: Uint8Array): Search;
static deserializeBinaryFromReader(message: Search, reader: jspb.BinaryReader): Search;
}
export namespace Search {
export type AsObject = {
nameLike: string,
show: boolean,
}
}
}
export class ListMemberLevelsResponse extends jspb.Message {
hasError(): boolean;
clearError(): void;
getError(): protobuf_rpc_pb.Error | undefined;
setError(value?: protobuf_rpc_pb.Error): void;
hasResult(): boolean;
clearResult(): void;
getResult(): ListMemberLevelsResponse.Result | undefined;
setResult(value?: ListMemberLevelsResponse.Result): void;
serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): ListMemberLevelsResponse.AsObject;
static toObject(includeInstance: boolean, msg: ListMemberLevelsResponse): ListMemberLevelsResponse.AsObject;
static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
static serializeBinaryToWriter(message: ListMemberLevelsResponse, writer: jspb.BinaryWriter): void;
static deserializeBinary(bytes: Uint8Array): ListMemberLevelsResponse;
static deserializeBinaryFromReader(message: ListMemberLevelsResponse, reader: jspb.BinaryReader): ListMemberLevelsResponse;
}
export namespace ListMemberLevelsResponse {
export type AsObject = {
error?: protobuf_rpc_pb.Error.AsObject,
result?: ListMemberLevelsResponse.Result.AsObject,
}
export class Result extends jspb.Message {
clearMemberLevelsList(): void;
getMemberLevelsList(): Array<models_member_level_pb.MemberLevel>;
setMemberLevelsList(value: Array<models_member_level_pb.MemberLevel>): void;
addMemberLevels(value?: models_member_level_pb.MemberLevel, index?: number): models_member_level_pb.MemberLevel;
serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): Result.AsObject;
static toObject(includeInstance: boolean, msg: Result): Result.AsObject;
static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
static serializeBinaryToWriter(message: Result, writer: jspb.BinaryWriter): void;
static deserializeBinary(bytes: Uint8Array): Result;
static deserializeBinaryFromReader(message: Result, reader: jspb.BinaryReader): Result;
}
export namespace Result {
export type AsObject = {
memberLevelsList: Array<models_member_level_pb.MemberLevel.AsObject>,
}
}
}
export class GetMemberLevelRequest extends jspb.Message {
getId(): string;
setId(value: string): void;
serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): GetMemberLevelRequest.AsObject;
static toObject(includeInstance: boolean, msg: GetMemberLevelRequest): GetMemberLevelRequest.AsObject;
static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
static serializeBinaryToWriter(message: GetMemberLevelRequest, writer: jspb.BinaryWriter): void;
static deserializeBinary(bytes: Uint8Array): GetMemberLevelRequest;
static deserializeBinaryFromReader(message: GetMemberLevelRequest, reader: jspb.BinaryReader): GetMemberLevelRequest;
}
export namespace GetMemberLevelRequest {
export type AsObject = {
id: string,
}
}
export class GetMemberLevelResponse extends jspb.Message {
hasError(): boolean;
clearError(): void;
getError(): protobuf_rpc_pb.Error | undefined;
setError(value?: protobuf_rpc_pb.Error): void;
hasResult(): boolean;
clearResult(): void;
getResult(): GetMemberLevelResponse.Result | undefined;
setResult(value?: GetMemberLevelResponse.Result): void;
serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): GetMemberLevelResponse.AsObject;
static toObject(includeInstance: boolean, msg: GetMemberLevelResponse): GetMemberLevelResponse.AsObject;
static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
static serializeBinaryToWriter(message: GetMemberLevelResponse, writer: jspb.BinaryWriter): void;
static deserializeBinary(bytes: Uint8Array): GetMemberLevelResponse;
static deserializeBinaryFromReader(message: GetMemberLevelResponse, reader: jspb.BinaryReader): GetMemberLevelResponse;
}
export namespace GetMemberLevelResponse {
export type AsObject = {
error?: protobuf_rpc_pb.Error.AsObject,
result?: GetMemberLevelResponse.Result.AsObject,
}
export class Result extends jspb.Message {
hasMemberLevel(): boolean;
clearMemberLevel(): void;
getMemberLevel(): models_member_level_pb.MemberLevel | undefined;
setMemberLevel(value?: models_member_level_pb.MemberLevel): void;
serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): Result.AsObject;
static toObject(includeInstance: boolean, msg: Result): Result.AsObject;
static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
static serializeBinaryToWriter(message: Result, writer: jspb.BinaryWriter): void;
static deserializeBinary(bytes: Uint8Array): Result;
static deserializeBinaryFromReader(message: Result, reader: jspb.BinaryReader): Result;
}
export namespace Result {
export type AsObject = {
memberLevel?: models_member_level_pb.MemberLevel.AsObject,
}
}
}
export class UpdateMemberLevelRequest extends jspb.Message {
getId(): string;
setId(value: string): void;
getName(): string;
setName(value: string): void;
getShow(): boolean;
setShow(value: boolean): void;
getSortOrder(): number;
setSortOrder(value: number): void;
serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): UpdateMemberLevelRequest.AsObject;
static toObject(includeInstance: boolean, msg: UpdateMemberLevelRequest): UpdateMemberLevelRequest.AsObject;
static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
static serializeBinaryToWriter(message: UpdateMemberLevelRequest, writer: jspb.BinaryWriter): void;
static deserializeBinary(bytes: Uint8Array): UpdateMemberLevelRequest;
static deserializeBinaryFromReader(message: UpdateMemberLevelRequest, reader: jspb.BinaryReader): UpdateMemberLevelRequest;
}
export namespace UpdateMemberLevelRequest {
export type AsObject = {
id: string,
name: string,
show: boolean,
sortOrder: number,
}
}
export class UpdateMemberLevelResponse extends jspb.Message {
hasError(): boolean;
clearError(): void;
getError(): protobuf_rpc_pb.Error | undefined;
setError(value?: protobuf_rpc_pb.Error): void;
hasResult(): boolean;
clearResult(): void;
getResult(): UpdateMemberLevelResponse.Result | undefined;
setResult(value?: UpdateMemberLevelResponse.Result): void;
serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): UpdateMemberLevelResponse.AsObject;
static toObject(includeInstance: boolean, msg: UpdateMemberLevelResponse): UpdateMemberLevelResponse.AsObject;
static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
static serializeBinaryToWriter(message: UpdateMemberLevelResponse, writer: jspb.BinaryWriter): void;
static deserializeBinary(bytes: Uint8Array): UpdateMemberLevelResponse;
static deserializeBinaryFromReader(message: UpdateMemberLevelResponse, reader: jspb.BinaryReader): UpdateMemberLevelResponse;
}
export namespace UpdateMemberLevelResponse {
export type AsObject = {
error?: protobuf_rpc_pb.Error.AsObject,
result?: UpdateMemberLevelResponse.Result.AsObject,
}
export class Result extends jspb.Message {
hasMemberLevel(): boolean;
clearMemberLevel(): void;
getMemberLevel(): models_member_level_pb.MemberLevel | undefined;
setMemberLevel(value?: models_member_level_pb.MemberLevel): void;
serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): Result.AsObject;
static toObject(includeInstance: boolean, msg: Result): Result.AsObject;
static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
static serializeBinaryToWriter(message: Result, writer: jspb.BinaryWriter): void;
static deserializeBinary(bytes: Uint8Array): Result;
static deserializeBinaryFromReader(message: Result, reader: jspb.BinaryReader): Result;
}
export namespace Result {
export type AsObject = {
memberLevel?: models_member_level_pb.MemberLevel.AsObject,
}
}
}
export class DeleteMemberLevelRequest extends jspb.Message {
getId(): string;
setId(value: string): void;
serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): DeleteMemberLevelRequest.AsObject;
static toObject(includeInstance: boolean, msg: DeleteMemberLevelRequest): DeleteMemberLevelRequest.AsObject;
static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
static serializeBinaryToWriter(message: DeleteMemberLevelRequest, writer: jspb.BinaryWriter): void;
static deserializeBinary(bytes: Uint8Array): DeleteMemberLevelRequest;
static deserializeBinaryFromReader(message: DeleteMemberLevelRequest, reader: jspb.BinaryReader): DeleteMemberLevelRequest;
}
export namespace DeleteMemberLevelRequest {
export type AsObject = {
id: string,
}
}
export class DeleteMemberLevelResponse extends jspb.Message {
hasError(): boolean;
clearError(): void;
getError(): protobuf_rpc_pb.Error | undefined;
setError(value?: protobuf_rpc_pb.Error): void;
hasResult(): boolean;
clearResult(): void;
getResult(): DeleteMemberLevelResponse.Result | undefined;
setResult(value?: DeleteMemberLevelResponse.Result): void;
serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): DeleteMemberLevelResponse.AsObject;
static toObject(includeInstance: boolean, msg: DeleteMemberLevelResponse): DeleteMemberLevelResponse.AsObject;
static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
static serializeBinaryToWriter(message: DeleteMemberLevelResponse, writer: jspb.BinaryWriter): void;
static deserializeBinary(bytes: Uint8Array): DeleteMemberLevelResponse;
static deserializeBinaryFromReader(message: DeleteMemberLevelResponse, reader: jspb.BinaryReader): DeleteMemberLevelResponse;
}
export namespace DeleteMemberLevelResponse {
export type AsObject = {
error?: protobuf_rpc_pb.Error.AsObject,
result?: DeleteMemberLevelResponse.Result.AsObject,
}
export class Result extends jspb.Message {
serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): Result.AsObject;
static toObject(includeInstance: boolean, msg: Result): Result.AsObject;
static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
static serializeBinaryToWriter(message: Result, writer: jspb.BinaryWriter): void;
static deserializeBinary(bytes: Uint8Array): Result;
static deserializeBinaryFromReader(message: Result, reader: jspb.BinaryReader): Result;
}
export namespace Result {
export type AsObject = {
}
}
}

3228
src/app/modules/proto/c2se/member_level_pb.js Normal file
View File

File diff suppressed because it is too large Load Diff

970
src/app/modules/proto/c2se/member_pb.d.ts vendored Normal file
View File

@ -0,0 +1,970 @@
// package: bet.beteran.c2se.member
// file: c2se/member.proto
import * as jspb from 'google-protobuf';
import * as protobuf_rpc_pb from '../protobuf/rpc_pb';
import * as protobuf_pagination_pb from '../protobuf/pagination_pb';
import * as models_member_pb from '../models/member_pb';
export class CreateMemberRequest extends jspb.Message {
getSiteId(): string;
setSiteId(value: string): void;
getMemberClassId(): string;
setMemberClassId(value: string): void;
getMemberLevelId(): string;
setMemberLevelId(value: string): void;
hasReferrerMemberUsername(): boolean;
clearReferrerMemberUsername(): void;
getReferrerMemberUsername(): string;
setReferrerMemberUsername(value: string): void;
getUsername(): string;
setUsername(value: string): void;
getPassword(): string;
setPassword(value: string): void;
getNickname(): string;
setNickname(value: string): void;
hasMobilePhoneNumber(): boolean;
clearMobilePhoneNumber(): void;
getMobilePhoneNumber(): string;
setMobilePhoneNumber(value: string): void;
hasBankAccount(): boolean;
clearBankAccount(): void;
getBankAccount(): CreateMemberRequest.BankAccount | undefined;
setBankAccount(value?: CreateMemberRequest.BankAccount): void;
serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): CreateMemberRequest.AsObject;
static toObject(
includeInstance: boolean,
msg: CreateMemberRequest
): CreateMemberRequest.AsObject;
static extensions: { [key: number]: jspb.ExtensionFieldInfo<jspb.Message> };
static extensionsBinary: {
[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>;
};
static serializeBinaryToWriter(
message: CreateMemberRequest,
writer: jspb.BinaryWriter
): void;
static deserializeBinary(bytes: Uint8Array): CreateMemberRequest;
static deserializeBinaryFromReader(
message: CreateMemberRequest,
reader: jspb.BinaryReader
): CreateMemberRequest;
}
export namespace CreateMemberRequest {
export type AsObject = {
siteId: string;
memberClassId: string;
memberLevelId: string;
referrerMemberUsername: string;
username: string;
password: string;
nickname: string;
mobilePhoneNumber: string;
bankAccount?: CreateMemberRequest.BankAccount.AsObject;
};
export class BankAccount extends jspb.Message {
getBankId(): string;
setBankId(value: string): void;
getName(): string;
setName(value: string): void;
getAccountNumber(): string;
setAccountNumber(value: string): void;
getExchangePassword(): string;
setExchangePassword(value: string): void;
serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): BankAccount.AsObject;
static toObject(
includeInstance: boolean,
msg: BankAccount
): BankAccount.AsObject;
static extensions: { [key: number]: jspb.ExtensionFieldInfo<jspb.Message> };
static extensionsBinary: {
[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>;
};
static serializeBinaryToWriter(
message: BankAccount,
writer: jspb.BinaryWriter
): void;
static deserializeBinary(bytes: Uint8Array): BankAccount;
static deserializeBinaryFromReader(
message: BankAccount,
reader: jspb.BinaryReader
): BankAccount;
}
export namespace BankAccount {
export type AsObject = {
bankId: string;
name: string;
accountNumber: string;
exchangePassword: string;
};
}
}
export class CreateMemberResponse extends jspb.Message {
hasError(): boolean;
clearError(): void;
getError(): protobuf_rpc_pb.Error | undefined;
setError(value?: protobuf_rpc_pb.Error): void;
hasResult(): boolean;
clearResult(): void;
getResult(): CreateMemberResponse.Result | undefined;
setResult(value?: CreateMemberResponse.Result): void;
serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): CreateMemberResponse.AsObject;
static toObject(
includeInstance: boolean,
msg: CreateMemberResponse
): CreateMemberResponse.AsObject;
static extensions: { [key: number]: jspb.ExtensionFieldInfo<jspb.Message> };
static extensionsBinary: {
[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>;
};
static serializeBinaryToWriter(
message: CreateMemberResponse,
writer: jspb.BinaryWriter
): void;
static deserializeBinary(bytes: Uint8Array): CreateMemberResponse;
static deserializeBinaryFromReader(
message: CreateMemberResponse,
reader: jspb.BinaryReader
): CreateMemberResponse;
}
export namespace CreateMemberResponse {
export type AsObject = {
error?: protobuf_rpc_pb.Error.AsObject;
result?: CreateMemberResponse.Result.AsObject;
};
export class Result extends jspb.Message {
hasMember(): boolean;
clearMember(): void;
getMember(): models_member_pb.MemberModel | undefined;
setMember(value?: models_member_pb.MemberModel): void;
serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): Result.AsObject;
static toObject(includeInstance: boolean, msg: Result): Result.AsObject;
static extensions: { [key: number]: jspb.ExtensionFieldInfo<jspb.Message> };
static extensionsBinary: {
[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>;
};
static serializeBinaryToWriter(
message: Result,
writer: jspb.BinaryWriter
): void;
static deserializeBinary(bytes: Uint8Array): Result;
static deserializeBinaryFromReader(
message: Result,
reader: jspb.BinaryReader
): Result;
}
export namespace Result {
export type AsObject = {
member?: models_member_pb.MemberModel.AsObject;
};
}
}
export class ListMembersRequest extends jspb.Message {
hasPagination(): boolean;
clearPagination(): void;
getPagination(): protobuf_pagination_pb.Pagination | undefined;
setPagination(value?: protobuf_pagination_pb.Pagination): void;
clearSortsList(): void;
getSortsList(): Array<protobuf_pagination_pb.Sort>;
setSortsList(value: Array<protobuf_pagination_pb.Sort>): void;
addSorts(
value?: protobuf_pagination_pb.Sort,
index?: number
): protobuf_pagination_pb.Sort;
hasSearch(): boolean;
clearSearch(): void;
getSearch(): ListMembersRequest.Search | undefined;
setSearch(value?: ListMembersRequest.Search): void;
serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): ListMembersRequest.AsObject;
static toObject(
includeInstance: boolean,
msg: ListMembersRequest
): ListMembersRequest.AsObject;
static extensions: { [key: number]: jspb.ExtensionFieldInfo<jspb.Message> };
static extensionsBinary: {
[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>;
};
static serializeBinaryToWriter(
message: ListMembersRequest,
writer: jspb.BinaryWriter
): void;
static deserializeBinary(bytes: Uint8Array): ListMembersRequest;
static deserializeBinaryFromReader(
message: ListMembersRequest,
reader: jspb.BinaryReader
): ListMembersRequest;
}
export namespace ListMembersRequest {
export type AsObject = {
pagination?: protobuf_pagination_pb.Pagination.AsObject;
sortsList: Array<protobuf_pagination_pb.Sort.AsObject>;
search?: ListMembersRequest.Search.AsObject;
};
export class Search extends jspb.Message {
hasSiteId(): boolean;
clearSiteId(): void;
getSiteId(): string;
setSiteId(value: string): void;
hasMemberClassId(): boolean;
clearMemberClassId(): void;
getMemberClassId(): string;
setMemberClassId(value: string): void;
hasMemberLevelId(): boolean;
clearMemberLevelId(): void;
getMemberLevelId(): string;
setMemberLevelId(value: string): void;
hasReferrerMemberId(): boolean;
clearReferrerMemberId(): void;
getReferrerMemberId(): string;
setReferrerMemberId(value: string): void;
hasUsernameLike(): boolean;
clearUsernameLike(): void;
getUsernameLike(): string;
setUsernameLike(value: string): void;
hasNicknameLike(): boolean;
clearNicknameLike(): void;
getNicknameLike(): string;
setNicknameLike(value: string): void;
hasMobilePhoneNumberLike(): boolean;
clearMobilePhoneNumberLike(): void;
getMobilePhoneNumberLike(): string;
setMobilePhoneNumberLike(value: string): void;
hasLastSigninedIp(): boolean;
clearLastSigninedIp(): void;
getLastSigninedIp(): string;
setLastSigninedIp(value: string): void;
hasState(): boolean;
clearState(): void;
getState(): models_member_pb.MemberStateMap[keyof models_member_pb.MemberStateMap];
setState(
value: models_member_pb.MemberStateMap[keyof models_member_pb.MemberStateMap]
): void;
hasDeletedAt(): boolean;
clearDeletedAt(): void;
getDeletedAt(): number;
setDeletedAt(value: number): void;
serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): Search.AsObject;
static toObject(includeInstance: boolean, msg: Search): Search.AsObject;
static extensions: { [key: number]: jspb.ExtensionFieldInfo<jspb.Message> };
static extensionsBinary: {
[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>;
};
static serializeBinaryToWriter(
message: Search,
writer: jspb.BinaryWriter
): void;
static deserializeBinary(bytes: Uint8Array): Search;
static deserializeBinaryFromReader(
message: Search,
reader: jspb.BinaryReader
): Search;
}
export namespace Search {
export type AsObject = {
siteId: string;
memberClassId: string;
memberLevelId: string;
referrerMemberId: string;
usernameLike: string;
nicknameLike: string;
mobilePhoneNumberLike: string;
lastSigninedIp: string;
state: models_member_pb.MemberStateMap[keyof models_member_pb.MemberStateMap];
deletedAt: number;
};
}
}
export class ListMembersResponse extends jspb.Message {
hasError(): boolean;
clearError(): void;
getError(): protobuf_rpc_pb.Error | undefined;
setError(value?: protobuf_rpc_pb.Error): void;
hasResult(): boolean;
clearResult(): void;
getResult(): ListMembersResponse.Result | undefined;
setResult(value?: ListMembersResponse.Result): void;
serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): ListMembersResponse.AsObject;
static toObject(
includeInstance: boolean,
msg: ListMembersResponse
): ListMembersResponse.AsObject;
static extensions: { [key: number]: jspb.ExtensionFieldInfo<jspb.Message> };
static extensionsBinary: {
[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>;
};
static serializeBinaryToWriter(
message: ListMembersResponse,
writer: jspb.BinaryWriter
): void;
static deserializeBinary(bytes: Uint8Array): ListMembersResponse;
static deserializeBinaryFromReader(
message: ListMembersResponse,
reader: jspb.BinaryReader
): ListMembersResponse;
}
export namespace ListMembersResponse {
export type AsObject = {
error?: protobuf_rpc_pb.Error.AsObject;
result?: ListMembersResponse.Result.AsObject;
};
export class Result extends jspb.Message {
clearMembersList(): void;
getMembersList(): Array<models_member_pb.MemberModel>;
setMembersList(value: Array<models_member_pb.MemberModel>): void;
addMembers(
value?: models_member_pb.MemberModel,
index?: number
): models_member_pb.MemberModel;
serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): Result.AsObject;
static toObject(includeInstance: boolean, msg: Result): Result.AsObject;
static extensions: { [key: number]: jspb.ExtensionFieldInfo<jspb.Message> };
static extensionsBinary: {
[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>;
};
static serializeBinaryToWriter(
message: Result,
writer: jspb.BinaryWriter
): void;
static deserializeBinary(bytes: Uint8Array): Result;
static deserializeBinaryFromReader(
message: Result,
reader: jspb.BinaryReader
): Result;
}
export namespace Result {
export type AsObject = {
membersList: Array<models_member_pb.MemberModel.AsObject>;
};
}
}
export class GetMemberRequest extends jspb.Message {
getId(): string;
setId(value: string): void;
serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): GetMemberRequest.AsObject;
static toObject(
includeInstance: boolean,
msg: GetMemberRequest
): GetMemberRequest.AsObject;
static extensions: { [key: number]: jspb.ExtensionFieldInfo<jspb.Message> };
static extensionsBinary: {
[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>;
};
static serializeBinaryToWriter(
message: GetMemberRequest,
writer: jspb.BinaryWriter
): void;
static deserializeBinary(bytes: Uint8Array): GetMemberRequest;
static deserializeBinaryFromReader(
message: GetMemberRequest,
reader: jspb.BinaryReader
): GetMemberRequest;
}
export namespace GetMemberRequest {
export type AsObject = {
id: string;
};
}
export class GetMemberResponse extends jspb.Message {
hasError(): boolean;
clearError(): void;
getError(): protobuf_rpc_pb.Error | undefined;
setError(value?: protobuf_rpc_pb.Error): void;
hasResult(): boolean;
clearResult(): void;
getResult(): GetMemberResponse.Result | undefined;
setResult(value?: GetMemberResponse.Result): void;
serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): GetMemberResponse.AsObject;
static toObject(
includeInstance: boolean,
msg: GetMemberResponse
): GetMemberResponse.AsObject;
static extensions: { [key: number]: jspb.ExtensionFieldInfo<jspb.Message> };
static extensionsBinary: {
[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>;
};
static serializeBinaryToWriter(
message: GetMemberResponse,
writer: jspb.BinaryWriter
): void;
static deserializeBinary(bytes: Uint8Array): GetMemberResponse;
static deserializeBinaryFromReader(
message: GetMemberResponse,
reader: jspb.BinaryReader
): GetMemberResponse;
}
export namespace GetMemberResponse {
export type AsObject = {
error?: protobuf_rpc_pb.Error.AsObject;
result?: GetMemberResponse.Result.AsObject;
};
export class Result extends jspb.Message {
hasMember(): boolean;
clearMember(): void;
getMember(): models_member_pb.MemberModel | undefined;
setMember(value?: models_member_pb.MemberModel): void;
serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): Result.AsObject;
static toObject(includeInstance: boolean, msg: Result): Result.AsObject;
static extensions: { [key: number]: jspb.ExtensionFieldInfo<jspb.Message> };
static extensionsBinary: {
[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>;
};
static serializeBinaryToWriter(
message: Result,
writer: jspb.BinaryWriter
): void;
static deserializeBinary(bytes: Uint8Array): Result;
static deserializeBinaryFromReader(
message: Result,
reader: jspb.BinaryReader
): Result;
}
export namespace Result {
export type AsObject = {
member?: models_member_pb.MemberModel.AsObject;
};
}
}
export class GetMemberByUsernameRequest extends jspb.Message {
getUsername(): string;
setUsername(value: string): void;
serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): GetMemberByUsernameRequest.AsObject;
static toObject(
includeInstance: boolean,
msg: GetMemberByUsernameRequest
): GetMemberByUsernameRequest.AsObject;
static extensions: { [key: number]: jspb.ExtensionFieldInfo<jspb.Message> };
static extensionsBinary: {
[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>;
};
static serializeBinaryToWriter(
message: GetMemberByUsernameRequest,
writer: jspb.BinaryWriter
): void;
static deserializeBinary(bytes: Uint8Array): GetMemberByUsernameRequest;
static deserializeBinaryFromReader(
message: GetMemberByUsernameRequest,
reader: jspb.BinaryReader
): GetMemberByUsernameRequest;
}
export namespace GetMemberByUsernameRequest {
export type AsObject = {
username: string;
};
}
export class GetMemberByUsernameResponse extends jspb.Message {
hasError(): boolean;
clearError(): void;
getError(): protobuf_rpc_pb.Error | undefined;
setError(value?: protobuf_rpc_pb.Error): void;
hasResult(): boolean;
clearResult(): void;
getResult(): GetMemberByUsernameResponse.Result | undefined;
setResult(value?: GetMemberByUsernameResponse.Result): void;
serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): GetMemberByUsernameResponse.AsObject;
static toObject(
includeInstance: boolean,
msg: GetMemberByUsernameResponse
): GetMemberByUsernameResponse.AsObject;
static extensions: { [key: number]: jspb.ExtensionFieldInfo<jspb.Message> };
static extensionsBinary: {
[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>;
};
static serializeBinaryToWriter(
message: GetMemberByUsernameResponse,
writer: jspb.BinaryWriter
): void;
static deserializeBinary(bytes: Uint8Array): GetMemberByUsernameResponse;
static deserializeBinaryFromReader(
message: GetMemberByUsernameResponse,
reader: jspb.BinaryReader
): GetMemberByUsernameResponse;
}
export namespace GetMemberByUsernameResponse {
export type AsObject = {
error?: protobuf_rpc_pb.Error.AsObject;
result?: GetMemberByUsernameResponse.Result.AsObject;
};
export class Result extends jspb.Message {
hasMember(): boolean;
clearMember(): void;
getMember(): models_member_pb.MemberModel | undefined;
setMember(value?: models_member_pb.MemberModel): void;
serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): Result.AsObject;
static toObject(includeInstance: boolean, msg: Result): Result.AsObject;
static extensions: { [key: number]: jspb.ExtensionFieldInfo<jspb.Message> };
static extensionsBinary: {
[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>;
};
static serializeBinaryToWriter(
message: Result,
writer: jspb.BinaryWriter
): void;
static deserializeBinary(bytes: Uint8Array): Result;
static deserializeBinaryFromReader(
message: Result,
reader: jspb.BinaryReader
): Result;
}
export namespace Result {
export type AsObject = {
member?: models_member_pb.MemberModel.AsObject;
};
}
}
export class UpdateMemberRequest extends jspb.Message {
getId(): string;
setId(value: string): void;
hasSiteId(): boolean;
clearSiteId(): void;
getSiteId(): string;
setSiteId(value: string): void;
hasMemberLevelId(): boolean;
clearMemberLevelId(): void;
getMemberLevelId(): string;
setMemberLevelId(value: string): void;
hasPassword(): boolean;
clearPassword(): void;
getPassword(): string;
setPassword(value: string): void;
hasMobilePhoneNumber(): boolean;
clearMobilePhoneNumber(): void;
getMobilePhoneNumber(): string;
setMobilePhoneNumber(value: string): void;
hasBankAccount(): boolean;
clearBankAccount(): void;
getBankAccount(): UpdateMemberRequest.BankAccount | undefined;
setBankAccount(value?: UpdateMemberRequest.BankAccount): void;
serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): UpdateMemberRequest.AsObject;
static toObject(
includeInstance: boolean,
msg: UpdateMemberRequest
): UpdateMemberRequest.AsObject;
static extensions: { [key: number]: jspb.ExtensionFieldInfo<jspb.Message> };
static extensionsBinary: {
[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>;
};
static serializeBinaryToWriter(
message: UpdateMemberRequest,
writer: jspb.BinaryWriter
): void;
static deserializeBinary(bytes: Uint8Array): UpdateMemberRequest;
static deserializeBinaryFromReader(
message: UpdateMemberRequest,
reader: jspb.BinaryReader
): UpdateMemberRequest;
}
export namespace UpdateMemberRequest {
export type AsObject = {
id: string;
siteId: string;
memberLevelId: string;
password: string;
mobilePhoneNumber: string;
bankAccount?: UpdateMemberRequest.BankAccount.AsObject;
};
export class BankAccount extends jspb.Message {
getId(): string;
setId(value: string): void;
getBankId(): string;
setBankId(value: string): void;
getName(): string;
setName(value: string): void;
getAccountNumber(): string;
setAccountNumber(value: string): void;
getExchangePassword(): string;
setExchangePassword(value: string): void;
serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): BankAccount.AsObject;
static toObject(
includeInstance: boolean,
msg: BankAccount
): BankAccount.AsObject;
static extensions: { [key: number]: jspb.ExtensionFieldInfo<jspb.Message> };
static extensionsBinary: {
[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>;
};
static serializeBinaryToWriter(
message: BankAccount,
writer: jspb.BinaryWriter
): void;
static deserializeBinary(bytes: Uint8Array): BankAccount;
static deserializeBinaryFromReader(
message: BankAccount,
reader: jspb.BinaryReader
): BankAccount;
}
export namespace BankAccount {
export type AsObject = {
id: string;
bankId: string;
name: string;
accountNumber: string;
exchangePassword: string;
};
}
}
export class UpdateMemberResponse extends jspb.Message {
hasError(): boolean;
clearError(): void;
getError(): protobuf_rpc_pb.Error | undefined;
setError(value?: protobuf_rpc_pb.Error): void;
hasResult(): boolean;
clearResult(): void;
getResult(): UpdateMemberResponse.Result | undefined;
setResult(value?: UpdateMemberResponse.Result): void;
serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): UpdateMemberResponse.AsObject;
static toObject(
includeInstance: boolean,
msg: UpdateMemberResponse
): UpdateMemberResponse.AsObject;
static extensions: { [key: number]: jspb.ExtensionFieldInfo<jspb.Message> };
static extensionsBinary: {
[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>;
};
static serializeBinaryToWriter(
message: UpdateMemberResponse,
writer: jspb.BinaryWriter
): void;
static deserializeBinary(bytes: Uint8Array): UpdateMemberResponse;
static deserializeBinaryFromReader(
message: UpdateMemberResponse,
reader: jspb.BinaryReader
): UpdateMemberResponse;
}
export namespace UpdateMemberResponse {
export type AsObject = {
error?: protobuf_rpc_pb.Error.AsObject;
result?: UpdateMemberResponse.Result.AsObject;
};
export class Result extends jspb.Message {
hasMember(): boolean;
clearMember(): void;
getMember(): models_member_pb.MemberModel | undefined;
setMember(value?: models_member_pb.MemberModel): void;
serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): Result.AsObject;
static toObject(includeInstance: boolean, msg: Result): Result.AsObject;
static extensions: { [key: number]: jspb.ExtensionFieldInfo<jspb.Message> };
static extensionsBinary: {
[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>;
};
static serializeBinaryToWriter(
message: Result,
writer: jspb.BinaryWriter
): void;
static deserializeBinary(bytes: Uint8Array): Result;
static deserializeBinaryFromReader(
message: Result,
reader: jspb.BinaryReader
): Result;
}
export namespace Result {
export type AsObject = {
member?: models_member_pb.MemberModel.AsObject;
};
}
}
export class UpdateMemberForStateRequest extends jspb.Message {
getId(): string;
setId(value: string): void;
getState(): models_member_pb.MemberStateMap[keyof models_member_pb.MemberStateMap];
setState(
value: models_member_pb.MemberStateMap[keyof models_member_pb.MemberStateMap]
): void;
serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): UpdateMemberForStateRequest.AsObject;
static toObject(
includeInstance: boolean,
msg: UpdateMemberForStateRequest
): UpdateMemberForStateRequest.AsObject;
static extensions: { [key: number]: jspb.ExtensionFieldInfo<jspb.Message> };
static extensionsBinary: {
[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>;
};
static serializeBinaryToWriter(
message: UpdateMemberForStateRequest,
writer: jspb.BinaryWriter
): void;
static deserializeBinary(bytes: Uint8Array): UpdateMemberForStateRequest;
static deserializeBinaryFromReader(
message: UpdateMemberForStateRequest,
reader: jspb.BinaryReader
): UpdateMemberForStateRequest;
}
export namespace UpdateMemberForStateRequest {
export type AsObject = {
id: string;
state: models_member_pb.MemberStateMap[keyof models_member_pb.MemberStateMap];
};
}
export class UpdateMemberForStateResponse extends jspb.Message {
hasError(): boolean;
clearError(): void;
getError(): protobuf_rpc_pb.Error | undefined;
setError(value?: protobuf_rpc_pb.Error): void;
hasResult(): boolean;
clearResult(): void;
getResult(): UpdateMemberForStateResponse.Result | undefined;
setResult(value?: UpdateMemberForStateResponse.Result): void;
serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): UpdateMemberForStateResponse.AsObject;
static toObject(
includeInstance: boolean,
msg: UpdateMemberForStateResponse
): UpdateMemberForStateResponse.AsObject;
static extensions: { [key: number]: jspb.ExtensionFieldInfo<jspb.Message> };
static extensionsBinary: {
[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>;
};
static serializeBinaryToWriter(
message: UpdateMemberForStateResponse,
writer: jspb.BinaryWriter
): void;
static deserializeBinary(bytes: Uint8Array): UpdateMemberForStateResponse;
static deserializeBinaryFromReader(
message: UpdateMemberForStateResponse,
reader: jspb.BinaryReader
): UpdateMemberForStateResponse;
}
export namespace UpdateMemberForStateResponse {
export type AsObject = {
error?: protobuf_rpc_pb.Error.AsObject;
result?: UpdateMemberForStateResponse.Result.AsObject;
};
export class Result extends jspb.Message {
hasMember(): boolean;
clearMember(): void;
getMember(): models_member_pb.MemberModel | undefined;
setMember(value?: models_member_pb.MemberModel): void;
serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): Result.AsObject;
static toObject(includeInstance: boolean, msg: Result): Result.AsObject;
static extensions: { [key: number]: jspb.ExtensionFieldInfo<jspb.Message> };
static extensionsBinary: {
[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>;
};
static serializeBinaryToWriter(
message: Result,
writer: jspb.BinaryWriter
): void;
static deserializeBinary(bytes: Uint8Array): Result;
static deserializeBinaryFromReader(
message: Result,
reader: jspb.BinaryReader
): Result;
}
export namespace Result {
export type AsObject = {
member?: models_member_pb.MemberModel.AsObject;
};
}
}
export class DeleteMemberRequest extends jspb.Message {
getId(): string;
setId(value: string): void;
serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): DeleteMemberRequest.AsObject;
static toObject(
includeInstance: boolean,
msg: DeleteMemberRequest
): DeleteMemberRequest.AsObject;
static extensions: { [key: number]: jspb.ExtensionFieldInfo<jspb.Message> };
static extensionsBinary: {
[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>;
};
static serializeBinaryToWriter(
message: DeleteMemberRequest,
writer: jspb.BinaryWriter
): void;
static deserializeBinary(bytes: Uint8Array): DeleteMemberRequest;
static deserializeBinaryFromReader(
message: DeleteMemberRequest,
reader: jspb.BinaryReader
): DeleteMemberRequest;
}
export namespace DeleteMemberRequest {
export type AsObject = {
id: string;
};
}
export class DeleteMemberResponse extends jspb.Message {
hasError(): boolean;
clearError(): void;
getError(): protobuf_rpc_pb.Error | undefined;
setError(value?: protobuf_rpc_pb.Error): void;
hasResult(): boolean;
clearResult(): void;
getResult(): DeleteMemberResponse.Result | undefined;
setResult(value?: DeleteMemberResponse.Result): void;
serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): DeleteMemberResponse.AsObject;
static toObject(
includeInstance: boolean,
msg: DeleteMemberResponse
): DeleteMemberResponse.AsObject;
static extensions: { [key: number]: jspb.ExtensionFieldInfo<jspb.Message> };
static extensionsBinary: {
[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>;
};
static serializeBinaryToWriter(
message: DeleteMemberResponse,
writer: jspb.BinaryWriter
): void;
static deserializeBinary(bytes: Uint8Array): DeleteMemberResponse;
static deserializeBinaryFromReader(
message: DeleteMemberResponse,
reader: jspb.BinaryReader
): DeleteMemberResponse;
}
export namespace DeleteMemberResponse {
export type AsObject = {
error?: protobuf_rpc_pb.Error.AsObject;
result?: DeleteMemberResponse.Result.AsObject;
};
export class Result extends jspb.Message {
serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): Result.AsObject;
static toObject(includeInstance: boolean, msg: Result): Result.AsObject;
static extensions: { [key: number]: jspb.ExtensionFieldInfo<jspb.Message> };
static extensionsBinary: {
[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>;
};
static serializeBinaryToWriter(
message: Result,
writer: jspb.BinaryWriter
): void;
static deserializeBinary(bytes: Uint8Array): Result;
static deserializeBinaryFromReader(
message: Result,
reader: jspb.BinaryReader
): Result;
}
export namespace Result {
export type AsObject = {};
}
}

6262
src/app/modules/proto/c2se/member_pb.js Normal file
View File

File diff suppressed because it is too large Load Diff

486
src/app/modules/proto/c2se/site_pb.d.ts vendored Normal file
View File

@ -0,0 +1,486 @@
// package: bet.beteran.c2se.site
// file: c2se/site.proto
import * as jspb from "google-protobuf";
import * as protobuf_rpc_pb from "../protobuf/rpc_pb";
import * as protobuf_pagination_pb from "../protobuf/pagination_pb";
import * as models_site_pb from "../models/site_pb";
export class CreateSiteRequest extends jspb.Message {
getUrl(): string;
setUrl(value: string): void;
hasName(): boolean;
clearName(): void;
getName(): string;
setName(value: string): void;
hasPath(): boolean;
clearPath(): void;
getPath(): string;
setPath(value: string): void;
getShow(): boolean;
setShow(value: boolean): void;
getCanUse(): boolean;
setCanUse(value: boolean): void;
hasMemo(): boolean;
clearMemo(): void;
getMemo(): string;
setMemo(value: string): void;
hasExpiresAt(): boolean;
clearExpiresAt(): void;
getExpiresAt(): number;
setExpiresAt(value: number): void;
serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): CreateSiteRequest.AsObject;
static toObject(includeInstance: boolean, msg: CreateSiteRequest): CreateSiteRequest.AsObject;
static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
static serializeBinaryToWriter(message: CreateSiteRequest, writer: jspb.BinaryWriter): void;
static deserializeBinary(bytes: Uint8Array): CreateSiteRequest;
static deserializeBinaryFromReader(message: CreateSiteRequest, reader: jspb.BinaryReader): CreateSiteRequest;
}
export namespace CreateSiteRequest {
export type AsObject = {
url: string,
name: string,
path: string,
show: boolean,
canUse: boolean,
memo: string,
expiresAt: number,
}
}
export class CreateSiteResponse extends jspb.Message {
hasError(): boolean;
clearError(): void;
getError(): protobuf_rpc_pb.Error | undefined;
setError(value?: protobuf_rpc_pb.Error): void;
hasResult(): boolean;
clearResult(): void;
getResult(): CreateSiteResponse.Result | undefined;
setResult(value?: CreateSiteResponse.Result): void;
serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): CreateSiteResponse.AsObject;
static toObject(includeInstance: boolean, msg: CreateSiteResponse): CreateSiteResponse.AsObject;
static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
static serializeBinaryToWriter(message: CreateSiteResponse, writer: jspb.BinaryWriter): void;
static deserializeBinary(bytes: Uint8Array): CreateSiteResponse;
static deserializeBinaryFromReader(message: CreateSiteResponse, reader: jspb.BinaryReader): CreateSiteResponse;
}
export namespace CreateSiteResponse {
export type AsObject = {
error?: protobuf_rpc_pb.Error.AsObject,
result?: CreateSiteResponse.Result.AsObject,
}
export class Result extends jspb.Message {
hasSite(): boolean;
clearSite(): void;
getSite(): models_site_pb.Site | undefined;
setSite(value?: models_site_pb.Site): void;
serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): Result.AsObject;
static toObject(includeInstance: boolean, msg: Result): Result.AsObject;
static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
static serializeBinaryToWriter(message: Result, writer: jspb.BinaryWriter): void;
static deserializeBinary(bytes: Uint8Array): Result;
static deserializeBinaryFromReader(message: Result, reader: jspb.BinaryReader): Result;
}
export namespace Result {
export type AsObject = {
site?: models_site_pb.Site.AsObject,
}
}
}
export class ListSitesRequest extends jspb.Message {
hasPagination(): boolean;
clearPagination(): void;
getPagination(): protobuf_pagination_pb.Pagination | undefined;
setPagination(value?: protobuf_pagination_pb.Pagination): void;
clearSortsList(): void;
getSortsList(): Array<protobuf_pagination_pb.Sort>;
setSortsList(value: Array<protobuf_pagination_pb.Sort>): void;
addSorts(value?: protobuf_pagination_pb.Sort, index?: number): protobuf_pagination_pb.Sort;
hasSearch(): boolean;
clearSearch(): void;
getSearch(): ListSitesRequest.Search | undefined;
setSearch(value?: ListSitesRequest.Search): void;
serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): ListSitesRequest.AsObject;
static toObject(includeInstance: boolean, msg: ListSitesRequest): ListSitesRequest.AsObject;
static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
static serializeBinaryToWriter(message: ListSitesRequest, writer: jspb.BinaryWriter): void;
static deserializeBinary(bytes: Uint8Array): ListSitesRequest;
static deserializeBinaryFromReader(message: ListSitesRequest, reader: jspb.BinaryReader): ListSitesRequest;
}
export namespace ListSitesRequest {
export type AsObject = {
pagination?: protobuf_pagination_pb.Pagination.AsObject,
sortsList: Array<protobuf_pagination_pb.Sort.AsObject>,
search?: ListSitesRequest.Search.AsObject,
}
export class Search extends jspb.Message {
hasUrlLike(): boolean;
clearUrlLike(): void;
getUrlLike(): string;
setUrlLike(value: string): void;
hasNameLike(): boolean;
clearNameLike(): void;
getNameLike(): string;
setNameLike(value: string): void;
hasPathLike(): boolean;
clearPathLike(): void;
getPathLike(): string;
setPathLike(value: string): void;
hasShow(): boolean;
clearShow(): void;
getShow(): boolean;
setShow(value: boolean): void;
hasCanUse(): boolean;
clearCanUse(): void;
getCanUse(): boolean;
setCanUse(value: boolean): void;
hasMemoLike(): boolean;
clearMemoLike(): void;
getMemoLike(): string;
setMemoLike(value: string): void;
serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): Search.AsObject;
static toObject(includeInstance: boolean, msg: Search): Search.AsObject;
static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
static serializeBinaryToWriter(message: Search, writer: jspb.BinaryWriter): void;
static deserializeBinary(bytes: Uint8Array): Search;
static deserializeBinaryFromReader(message: Search, reader: jspb.BinaryReader): Search;
}
export namespace Search {
export type AsObject = {
urlLike: string,
nameLike: string,
pathLike: string,
show: boolean,
canUse: boolean,
memoLike: string,
}
}
}
export class ListSitesResponse extends jspb.Message {
hasError(): boolean;
clearError(): void;
getError(): protobuf_rpc_pb.Error | undefined;
setError(value?: protobuf_rpc_pb.Error): void;
hasResult(): boolean;
clearResult(): void;
getResult(): ListSitesResponse.Result | undefined;
setResult(value?: ListSitesResponse.Result): void;
serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): ListSitesResponse.AsObject;
static toObject(includeInstance: boolean, msg: ListSitesResponse): ListSitesResponse.AsObject;
static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
static serializeBinaryToWriter(message: ListSitesResponse, writer: jspb.BinaryWriter): void;
static deserializeBinary(bytes: Uint8Array): ListSitesResponse;
static deserializeBinaryFromReader(message: ListSitesResponse, reader: jspb.BinaryReader): ListSitesResponse;
}
export namespace ListSitesResponse {
export type AsObject = {
error?: protobuf_rpc_pb.Error.AsObject,
result?: ListSitesResponse.Result.AsObject,
}
export class Result extends jspb.Message {
clearSitesList(): void;
getSitesList(): Array<models_site_pb.Site>;
setSitesList(value: Array<models_site_pb.Site>): void;
addSites(value?: models_site_pb.Site, index?: number): models_site_pb.Site;
serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): Result.AsObject;
static toObject(includeInstance: boolean, msg: Result): Result.AsObject;
static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
static serializeBinaryToWriter(message: Result, writer: jspb.BinaryWriter): void;
static deserializeBinary(bytes: Uint8Array): Result;
static deserializeBinaryFromReader(message: Result, reader: jspb.BinaryReader): Result;
}
export namespace Result {
export type AsObject = {
sitesList: Array<models_site_pb.Site.AsObject>,
}
}
}
export class GetSiteRequest extends jspb.Message {
getId(): string;
setId(value: string): void;
serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): GetSiteRequest.AsObject;
static toObject(includeInstance: boolean, msg: GetSiteRequest): GetSiteRequest.AsObject;
static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
static serializeBinaryToWriter(message: GetSiteRequest, writer: jspb.BinaryWriter): void;
static deserializeBinary(bytes: Uint8Array): GetSiteRequest;
static deserializeBinaryFromReader(message: GetSiteRequest, reader: jspb.BinaryReader): GetSiteRequest;
}
export namespace GetSiteRequest {
export type AsObject = {
id: string,
}
}
export class GetSiteResponse extends jspb.Message {
hasError(): boolean;
clearError(): void;
getError(): protobuf_rpc_pb.Error | undefined;
setError(value?: protobuf_rpc_pb.Error): void;
hasResult(): boolean;
clearResult(): void;
getResult(): GetSiteResponse.Result | undefined;
setResult(value?: GetSiteResponse.Result): void;
serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): GetSiteResponse.AsObject;
static toObject(includeInstance: boolean, msg: GetSiteResponse): GetSiteResponse.AsObject;
static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
static serializeBinaryToWriter(message: GetSiteResponse, writer: jspb.BinaryWriter): void;
static deserializeBinary(bytes: Uint8Array): GetSiteResponse;
static deserializeBinaryFromReader(message: GetSiteResponse, reader: jspb.BinaryReader): GetSiteResponse;
}
export namespace GetSiteResponse {
export type AsObject = {
error?: protobuf_rpc_pb.Error.AsObject,
result?: GetSiteResponse.Result.AsObject,
}
export class Result extends jspb.Message {
hasSite(): boolean;
clearSite(): void;
getSite(): models_site_pb.Site | undefined;
setSite(value?: models_site_pb.Site): void;
serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): Result.AsObject;
static toObject(includeInstance: boolean, msg: Result): Result.AsObject;
static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
static serializeBinaryToWriter(message: Result, writer: jspb.BinaryWriter): void;
static deserializeBinary(bytes: Uint8Array): Result;
static deserializeBinaryFromReader(message: Result, reader: jspb.BinaryReader): Result;
}
export namespace Result {
export type AsObject = {
site?: models_site_pb.Site.AsObject,
}
}
}
export class UpdateSiteRequest extends jspb.Message {
getId(): string;
setId(value: string): void;
getUrl(): string;
setUrl(value: string): void;
hasName(): boolean;
clearName(): void;
getName(): string;
setName(value: string): void;
hasPath(): boolean;
clearPath(): void;
getPath(): string;
setPath(value: string): void;
getShow(): boolean;
setShow(value: boolean): void;
getCanUse(): boolean;
setCanUse(value: boolean): void;
hasMemo(): boolean;
clearMemo(): void;
getMemo(): string;
setMemo(value: string): void;
hasExpiresAt(): boolean;
clearExpiresAt(): void;
getExpiresAt(): number;
setExpiresAt(value: number): void;
serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): UpdateSiteRequest.AsObject;
static toObject(includeInstance: boolean, msg: UpdateSiteRequest): UpdateSiteRequest.AsObject;
static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
static serializeBinaryToWriter(message: UpdateSiteRequest, writer: jspb.BinaryWriter): void;
static deserializeBinary(bytes: Uint8Array): UpdateSiteRequest;
static deserializeBinaryFromReader(message: UpdateSiteRequest, reader: jspb.BinaryReader): UpdateSiteRequest;
}
export namespace UpdateSiteRequest {
export type AsObject = {
id: string,
url: string,
name: string,
path: string,
show: boolean,
canUse: boolean,
memo: string,
expiresAt: number,
}
}
export class UpdateSiteResponse extends jspb.Message {
hasError(): boolean;
clearError(): void;
getError(): protobuf_rpc_pb.Error | undefined;
setError(value?: protobuf_rpc_pb.Error): void;
hasResult(): boolean;
clearResult(): void;
getResult(): UpdateSiteResponse.Result | undefined;
setResult(value?: UpdateSiteResponse.Result): void;
serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): UpdateSiteResponse.AsObject;
static toObject(includeInstance: boolean, msg: UpdateSiteResponse): UpdateSiteResponse.AsObject;
static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
static serializeBinaryToWriter(message: UpdateSiteResponse, writer: jspb.BinaryWriter): void;
static deserializeBinary(bytes: Uint8Array): UpdateSiteResponse;
static deserializeBinaryFromReader(message: UpdateSiteResponse, reader: jspb.BinaryReader): UpdateSiteResponse;
}
export namespace UpdateSiteResponse {
export type AsObject = {
error?: protobuf_rpc_pb.Error.AsObject,
result?: UpdateSiteResponse.Result.AsObject,
}
export class Result extends jspb.Message {
hasSite(): boolean;
clearSite(): void;
getSite(): models_site_pb.Site | undefined;
setSite(value?: models_site_pb.Site): void;
serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): Result.AsObject;
static toObject(includeInstance: boolean, msg: Result): Result.AsObject;
static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
static serializeBinaryToWriter(message: Result, writer: jspb.BinaryWriter): void;
static deserializeBinary(bytes: Uint8Array): Result;
static deserializeBinaryFromReader(message: Result, reader: jspb.BinaryReader): Result;
}
export namespace Result {
export type AsObject = {
site?: models_site_pb.Site.AsObject,
}
}
}
export class DeleteSiteRequest extends jspb.Message {
getId(): string;
setId(value: string): void;
serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): DeleteSiteRequest.AsObject;
static toObject(includeInstance: boolean, msg: DeleteSiteRequest): DeleteSiteRequest.AsObject;
static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
static serializeBinaryToWriter(message: DeleteSiteRequest, writer: jspb.BinaryWriter): void;
static deserializeBinary(bytes: Uint8Array): DeleteSiteRequest;
static deserializeBinaryFromReader(message: DeleteSiteRequest, reader: jspb.BinaryReader): DeleteSiteRequest;
}
export namespace DeleteSiteRequest {
export type AsObject = {
id: string,
}
}
export class DeleteSiteResponse extends jspb.Message {
hasError(): boolean;
clearError(): void;
getError(): protobuf_rpc_pb.Error | undefined;
setError(value?: protobuf_rpc_pb.Error): void;
hasResult(): boolean;
clearResult(): void;
getResult(): DeleteSiteResponse.Result | undefined;
setResult(value?: DeleteSiteResponse.Result): void;
serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): DeleteSiteResponse.AsObject;
static toObject(includeInstance: boolean, msg: DeleteSiteResponse): DeleteSiteResponse.AsObject;
static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
static serializeBinaryToWriter(message: DeleteSiteResponse, writer: jspb.BinaryWriter): void;
static deserializeBinary(bytes: Uint8Array): DeleteSiteResponse;
static deserializeBinaryFromReader(message: DeleteSiteResponse, reader: jspb.BinaryReader): DeleteSiteResponse;
}
export namespace DeleteSiteResponse {
export type AsObject = {
error?: protobuf_rpc_pb.Error.AsObject,
result?: DeleteSiteResponse.Result.AsObject,
}
export class Result extends jspb.Message {
serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): Result.AsObject;
static toObject(includeInstance: boolean, msg: Result): Result.AsObject;
static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
static serializeBinaryToWriter(message: Result, writer: jspb.BinaryWriter): void;
static deserializeBinary(bytes: Uint8Array): Result;
static deserializeBinaryFromReader(message: Result, reader: jspb.BinaryReader): Result;
}
export namespace Result {
export type AsObject = {
}
}
}

3804
src/app/modules/proto/c2se/site_pb.js Normal file
View File

File diff suppressed because it is too large Load Diff

76
src/app/modules/proto/models/api/vendor_pb.d.ts vendored Normal file
View File

@ -0,0 +1,76 @@
// package: bet.beteran.api.vendor
// file: models/api/vendor.proto
import * as jspb from 'google-protobuf';
export class Vendor extends jspb.Message {
getId(): number;
setId(value: number): void;
getCompanyId(): number;
setCompanyId(value: number): void;
getVendorId(): number;
setVendorId(value: number): void;
getKey(): string;
setKey(value: string): void;
getName(): string;
setName(value: string): void;
getCategory(): string;
setCategory(value: string): void;
getMaxBetCasino(): number;
setMaxBetCasino(value: number): void;
getMaxBetSlot(): number;
setMaxBetSlot(value: number): void;
getIsEnable(): string;
setIsEnable(value: string): void;
getBetCount(): number;
setBetCount(value: number): void;
getCreatedAt(): number;
setCreatedAt(value: number): void;
getUpdatedAt(): number;
setUpdatedAt(value: number): void;
serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): Vendor.AsObject;
static toObject(includeInstance: boolean, msg: Vendor): Vendor.AsObject;
static extensions: { [key: number]: jspb.ExtensionFieldInfo<jspb.Message> };
static extensionsBinary: {
[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>;
};
static serializeBinaryToWriter(
message: Vendor,
writer: jspb.BinaryWriter
): void;
static deserializeBinary(bytes: Uint8Array): Vendor;
static deserializeBinaryFromReader(
message: Vendor,
reader: jspb.BinaryReader
): Vendor;
}
export namespace Vendor {
export type AsObject = {
id: number;
companyId: number;
vendorId: number;
key: string;
name: string;
category: string;
maxBetCasino: number;
maxBetSlot: number;
isEnable: string;
betCount: number;
createdAt: number;
updatedAt: number;
};
}

455
src/app/modules/proto/models/api/vendor_pb.js Normal file
View File

@ -0,0 +1,455 @@
// source: models/api/vendor.proto
/**
* @fileoverview
* @enhanceable
* @suppress {missingRequire} reports error on implicit type usages.
* @suppress {messageConventions} JS Compiler reports an error if a variable or
* field starts with 'MSG_' and isn't a translatable message.
* @public
*/
// GENERATED CODE -- DO NOT EDIT!
/* eslint-disable */
// @ts-nocheck
var jspb = require("google-protobuf");
var goog = jspb;
var global = function () {
return this || window || global || self || Function("return this")();
}.call(null);
goog.exportSymbol("proto.bet.beteran.api.vendor.Vendor", null, global);
/**
* Generated by JsPbCodeGenerator.
* @param {Array=} opt_data Optional initial data array, typically from a
* server response, or constructed directly in Javascript. The array is used
* in place and becomes part of the constructed object. It is not cloned.
* If no data is provided, the constructed object will be empty, but still
* valid.
* @extends {jspb.Message}
* @constructor
*/
proto.bet.beteran.api.vendor.Vendor = function (opt_data) {
jspb.Message.initialize(this, opt_data, 0, -1, null, null);
};
goog.inherits(proto.bet.beteran.api.vendor.Vendor, jspb.Message);
if (goog.DEBUG && !COMPILED) {
/**
* @public
* @override
*/
proto.bet.beteran.api.vendor.Vendor.displayName =
"proto.bet.beteran.api.vendor.Vendor";
}
if (jspb.Message.GENERATE_TO_OBJECT) {
/**
* Creates an object representation of this proto.
* Field names that are reserved in JavaScript and will be renamed to pb_name.
* Optional fields that are not set will be set to undefined.
* To access a reserved field use, foo.pb_<name>, eg, foo.pb_default.
* For the list of reserved names please see:
* net/proto2/compiler/js/internal/generator.cc#kKeyword.
* @param {boolean=} opt_includeInstance Deprecated. whether to include the
* JSPB instance for transitional soy proto support:
* http://goto/soy-param-migration
* @return {!Object}
*/
proto.bet.beteran.api.vendor.Vendor.prototype.toObject = function (
opt_includeInstance
) {
return proto.bet.beteran.api.vendor.Vendor.toObject(
opt_includeInstance,
this
);
};
/**
* Static version of the {@see toObject} method.
* @param {boolean|undefined} includeInstance Deprecated. Whether to include
* the JSPB instance for transitional soy proto support:
* http://goto/soy-param-migration
* @param {!proto.bet.beteran.api.vendor.Vendor} msg The msg instance to transform.
* @return {!Object}
* @suppress {unusedLocalVariables} f is only used for nested messages
*/
proto.bet.beteran.api.vendor.Vendor.toObject = function (
includeInstance,
msg
) {
var f,
obj = {
id: jspb.Message.getFieldWithDefault(msg, 1, 0),
companyId: jspb.Message.getFieldWithDefault(msg, 2, 0),
vendorId: jspb.Message.getFieldWithDefault(msg, 3, 0),
key: jspb.Message.getFieldWithDefault(msg, 4, ""),
name: jspb.Message.getFieldWithDefault(msg, 5, ""),
category: jspb.Message.getFieldWithDefault(msg, 6, ""),
maxBetCasino: jspb.Message.getFieldWithDefault(msg, 7, 0),
maxBetSlot: jspb.Message.getFieldWithDefault(msg, 8, 0),
isEnable: jspb.Message.getFieldWithDefault(msg, 9, ""),
betCount: jspb.Message.getFieldWithDefault(msg, 10, 0),
createdAt: jspb.Message.getFieldWithDefault(msg, 11, 0),
updatedAt: jspb.Message.getFieldWithDefault(msg, 12, 0),
};
if (includeInstance) {
obj.$jspbMessageInstance = msg;
}
return obj;
};
}
/**
* Deserializes binary data (in protobuf wire format).
* @param {jspb.ByteSource} bytes The bytes to deserialize.
* @return {!proto.bet.beteran.api.vendor.Vendor}
*/
proto.bet.beteran.api.vendor.Vendor.deserializeBinary = function (bytes) {
var reader = new jspb.BinaryReader(bytes);
var msg = new proto.bet.beteran.api.vendor.Vendor();
return proto.bet.beteran.api.vendor.Vendor.deserializeBinaryFromReader(
msg,
reader
);
};
/**
* Deserializes binary data (in protobuf wire format) from the
* given reader into the given message object.
* @param {!proto.bet.beteran.api.vendor.Vendor} msg The message object to deserialize into.
* @param {!jspb.BinaryReader} reader The BinaryReader to use.
* @return {!proto.bet.beteran.api.vendor.Vendor}
*/
proto.bet.beteran.api.vendor.Vendor.deserializeBinaryFromReader = function (
msg,
reader
) {
while (reader.nextField()) {
if (reader.isEndGroup()) {
break;
}
var field = reader.getFieldNumber();
switch (field) {
case 1:
var value = /** @type {number} */ (reader.readUint64());
msg.setId(value);
break;
case 2:
var value = /** @type {number} */ (reader.readUint64());
msg.setCompanyId(value);
break;
case 3:
var value = /** @type {number} */ (reader.readUint64());
msg.setVendorId(value);
break;
case 4:
var value = /** @type {string} */ (reader.readString());
msg.setKey(value);
break;
case 5:
var value = /** @type {string} */ (reader.readString());
msg.setName(value);
break;
case 6:
var value = /** @type {string} */ (reader.readString());
msg.setCategory(value);
break;
case 7:
var value = /** @type {number} */ (reader.readUint64());
msg.setMaxBetCasino(value);
break;
case 8:
var value = /** @type {number} */ (reader.readUint64());
msg.setMaxBetSlot(value);
break;
case 9:
var value = /** @type {string} */ (reader.readString());
msg.setIsEnable(value);
break;
case 10:
var value = /** @type {number} */ (reader.readUint64());
msg.setBetCount(value);
break;
case 11:
var value = /** @type {number} */ (reader.readUint64());
msg.setCreatedAt(value);
break;
case 12:
var value = /** @type {number} */ (reader.readUint64());
msg.setUpdatedAt(value);
break;
default:
reader.skipField();
break;
}
}
return msg;
};
/**
* Serializes the message to binary data (in protobuf wire format).
* @return {!Uint8Array}
*/
proto.bet.beteran.api.vendor.Vendor.prototype.serializeBinary = function () {
var writer = new jspb.BinaryWriter();
proto.bet.beteran.api.vendor.Vendor.serializeBinaryToWriter(this, writer);
return writer.getResultBuffer();
};
/**
* Serializes the given message to binary data (in protobuf wire
* format), writing to the given BinaryWriter.
* @param {!proto.bet.beteran.api.vendor.Vendor} message
* @param {!jspb.BinaryWriter} writer
* @suppress {unusedLocalVariables} f is only used for nested messages
*/
proto.bet.beteran.api.vendor.Vendor.serializeBinaryToWriter = function (
message,
writer
) {
var f = undefined;
f = message.getId();
if (f !== 0) {
writer.writeUint64(1, f);
}
f = message.getCompanyId();
if (f !== 0) {
writer.writeUint64(2, f);
}
f = message.getVendorId();
if (f !== 0) {
writer.writeUint64(3, f);
}
f = message.getKey();
if (f.length > 0) {
writer.writeString(4, f);
}
f = message.getName();
if (f.length > 0) {
writer.writeString(5, f);
}
f = message.getCategory();
if (f.length > 0) {
writer.writeString(6, f);
}
f = message.getMaxBetCasino();
if (f !== 0) {
writer.writeUint64(7, f);
}
f = message.getMaxBetSlot();
if (f !== 0) {
writer.writeUint64(8, f);
}
f = message.getIsEnable();
if (f.length > 0) {
writer.writeString(9, f);
}
f = message.getBetCount();
if (f !== 0) {
writer.writeUint64(10, f);
}
f = message.getCreatedAt();
if (f !== 0) {
writer.writeUint64(11, f);
}
f = message.getUpdatedAt();
if (f !== 0) {
writer.writeUint64(12, f);
}
};
/**
* optional uint64 id = 1;
* @return {number}
*/
proto.bet.beteran.api.vendor.Vendor.prototype.getId = function () {
return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 1, 0));
};
/**
* @param {number} value
* @return {!proto.bet.beteran.api.vendor.Vendor} returns this
*/
proto.bet.beteran.api.vendor.Vendor.prototype.setId = function (value) {
return jspb.Message.setProto3IntField(this, 1, value);
};
/**
* optional uint64 company_id = 2;
* @return {number}
*/
proto.bet.beteran.api.vendor.Vendor.prototype.getCompanyId = function () {
return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 2, 0));
};
/**
* @param {number} value
* @return {!proto.bet.beteran.api.vendor.Vendor} returns this
*/
proto.bet.beteran.api.vendor.Vendor.prototype.setCompanyId = function (value) {
return jspb.Message.setProto3IntField(this, 2, value);
};
/**
* optional uint64 vendor_id = 3;
* @return {number}
*/
proto.bet.beteran.api.vendor.Vendor.prototype.getVendorId = function () {
return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 3, 0));
};
/**
* @param {number} value
* @return {!proto.bet.beteran.api.vendor.Vendor} returns this
*/
proto.bet.beteran.api.vendor.Vendor.prototype.setVendorId = function (value) {
return jspb.Message.setProto3IntField(this, 3, value);
};
/**
* optional string key = 4;
* @return {string}
*/
proto.bet.beteran.api.vendor.Vendor.prototype.getKey = function () {
return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 4, ""));
};
/**
* @param {string} value
* @return {!proto.bet.beteran.api.vendor.Vendor} returns this
*/
proto.bet.beteran.api.vendor.Vendor.prototype.setKey = function (value) {
return jspb.Message.setProto3StringField(this, 4, value);
};
/**
* optional string name = 5;
* @return {string}
*/
proto.bet.beteran.api.vendor.Vendor.prototype.getName = function () {
return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 5, ""));
};
/**
* @param {string} value
* @return {!proto.bet.beteran.api.vendor.Vendor} returns this
*/
proto.bet.beteran.api.vendor.Vendor.prototype.setName = function (value) {
return jspb.Message.setProto3StringField(this, 5, value);
};
/**
* optional string category = 6;
* @return {string}
*/
proto.bet.beteran.api.vendor.Vendor.prototype.getCategory = function () {
return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 6, ""));
};
/**
* @param {string} value
* @return {!proto.bet.beteran.api.vendor.Vendor} returns this
*/
proto.bet.beteran.api.vendor.Vendor.prototype.setCategory = function (value) {
return jspb.Message.setProto3StringField(this, 6, value);
};
/**
* optional uint64 max_bet_casino = 7;
* @return {number}
*/
proto.bet.beteran.api.vendor.Vendor.prototype.getMaxBetCasino = function () {
return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 7, 0));
};
/**
* @param {number} value
* @return {!proto.bet.beteran.api.vendor.Vendor} returns this
*/
proto.bet.beteran.api.vendor.Vendor.prototype.setMaxBetCasino = function (
value
) {
return jspb.Message.setProto3IntField(this, 7, value);
};
/**
* optional uint64 max_bet_slot = 8;
* @return {number}
*/
proto.bet.beteran.api.vendor.Vendor.prototype.getMaxBetSlot = function () {
return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 8, 0));
};
/**
* @param {number} value
* @return {!proto.bet.beteran.api.vendor.Vendor} returns this
*/
proto.bet.beteran.api.vendor.Vendor.prototype.setMaxBetSlot = function (value) {
return jspb.Message.setProto3IntField(this, 8, value);
};
/**
* optional string is_enable = 9;
* @return {string}
*/
proto.bet.beteran.api.vendor.Vendor.prototype.getIsEnable = function () {
return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 9, ""));
};
/**
* @param {string} value
* @return {!proto.bet.beteran.api.vendor.Vendor} returns this
*/
proto.bet.beteran.api.vendor.Vendor.prototype.setIsEnable = function (value) {
return jspb.Message.setProto3StringField(this, 9, value);
};
/**
* optional uint64 bet_count = 10;
* @return {number}
*/
proto.bet.beteran.api.vendor.Vendor.prototype.getBetCount = function () {
return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 10, 0));
};
/**
* @param {number} value
* @return {!proto.bet.beteran.api.vendor.Vendor} returns this
*/
proto.bet.beteran.api.vendor.Vendor.prototype.setBetCount = function (value) {
return jspb.Message.setProto3IntField(this, 10, value);
};
/**
* optional uint64 created_at = 11;
* @return {number}
*/
proto.bet.beteran.api.vendor.Vendor.prototype.getCreatedAt = function () {
return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 11, 0));
};
/**
* @param {number} value
* @return {!proto.bet.beteran.api.vendor.Vendor} returns this
*/
proto.bet.beteran.api.vendor.Vendor.prototype.setCreatedAt = function (value) {
return jspb.Message.setProto3IntField(this, 11, value);
};
/**
* optional uint64 updated_at = 12;
* @return {number}
*/
proto.bet.beteran.api.vendor.Vendor.prototype.getUpdatedAt = function () {
return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 12, 0));
};
/**
* @param {number} value
* @return {!proto.bet.beteran.api.vendor.Vendor} returns this
*/
proto.bet.beteran.api.vendor.Vendor.prototype.setUpdatedAt = function (value) {
return jspb.Message.setProto3IntField(this, 12, value);
};
goog.object.extend(exports, proto.bet.beteran.api.vendor);

55
src/app/modules/proto/models/bank_pb.d.ts vendored Normal file
View File

@ -0,0 +1,55 @@
// package: bet.beteran.bank
// file: models/bank.proto
import * as jspb from "google-protobuf";
export class Bank extends jspb.Message {
getId(): string;
setId(value: string): void;
getName(): string;
setName(value: string): void;
getSortOrder(): number;
setSortOrder(value: number): void;
getShow(): boolean;
setShow(value: boolean): void;
getCanUse(): boolean;
setCanUse(value: boolean): void;
hasMemo(): boolean;
clearMemo(): void;
getMemo(): string;
setMemo(value: string): void;
getCreatedAt(): number;
setCreatedAt(value: number): void;
getUpdatedAt(): number;
setUpdatedAt(value: number): void;
serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): Bank.AsObject;
static toObject(includeInstance: boolean, msg: Bank): Bank.AsObject;
static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
static serializeBinaryToWriter(message: Bank, writer: jspb.BinaryWriter): void;
static deserializeBinary(bytes: Uint8Array): Bank;
static deserializeBinaryFromReader(message: Bank, reader: jspb.BinaryReader): Bank;
}
export namespace Bank {
export type AsObject = {
id: string,
name: string,
sortOrder: number,
show: boolean,
canUse: boolean,
memo: string,
createdAt: number,
updatedAt: number,
}
}

398
src/app/modules/proto/models/bank_pb.js Normal file
View File

@ -0,0 +1,398 @@
// source: models/bank.proto
/**
* @fileoverview
* @enhanceable
* @suppress {missingRequire} reports error on implicit type usages.
* @suppress {messageConventions} JS Compiler reports an error if a variable or
* field starts with 'MSG_' and isn't a translatable message.
* @public
*/
// GENERATED CODE -- DO NOT EDIT!
/* eslint-disable */
// @ts-nocheck
var jspb = require('google-protobuf');
var goog = jspb;
var global = (function() { return this || window || global || self || Function('return this')(); }).call(null);
goog.exportSymbol('proto.bet.beteran.bank.Bank', null, global);
/**
* Generated by JsPbCodeGenerator.
* @param {Array=} opt_data Optional initial data array, typically from a
* server response, or constructed directly in Javascript. The array is used
* in place and becomes part of the constructed object. It is not cloned.
* If no data is provided, the constructed object will be empty, but still
* valid.
* @extends {jspb.Message}
* @constructor
*/
proto.bet.beteran.bank.Bank = function(opt_data) {
jspb.Message.initialize(this, opt_data, 0, -1, null, null);
};
goog.inherits(proto.bet.beteran.bank.Bank, jspb.Message);
if (goog.DEBUG && !COMPILED) {
/**
* @public
* @override
*/
proto.bet.beteran.bank.Bank.displayName = 'proto.bet.beteran.bank.Bank';
}
if (jspb.Message.GENERATE_TO_OBJECT) {
/**
* Creates an object representation of this proto.
* Field names that are reserved in JavaScript and will be renamed to pb_name.
* Optional fields that are not set will be set to undefined.
* To access a reserved field use, foo.pb_<name>, eg, foo.pb_default.
* For the list of reserved names please see:
* net/proto2/compiler/js/internal/generator.cc#kKeyword.
* @param {boolean=} opt_includeInstance Deprecated. whether to include the
* JSPB instance for transitional soy proto support:
* http://goto/soy-param-migration
* @return {!Object}
*/
proto.bet.beteran.bank.Bank.prototype.toObject = function(opt_includeInstance) {
return proto.bet.beteran.bank.Bank.toObject(opt_includeInstance, this);
};
/**
* Static version of the {@see toObject} method.
* @param {boolean|undefined} includeInstance Deprecated. Whether to include
* the JSPB instance for transitional soy proto support:
* http://goto/soy-param-migration
* @param {!proto.bet.beteran.bank.Bank} msg The msg instance to transform.
* @return {!Object}
* @suppress {unusedLocalVariables} f is only used for nested messages
*/
proto.bet.beteran.bank.Bank.toObject = function(includeInstance, msg) {
var f, obj = {
id: jspb.Message.getFieldWithDefault(msg, 1, ""),
name: jspb.Message.getFieldWithDefault(msg, 2, ""),
sortOrder: jspb.Message.getFieldWithDefault(msg, 3, 0),
show: jspb.Message.getBooleanFieldWithDefault(msg, 4, false),
canUse: jspb.Message.getBooleanFieldWithDefault(msg, 5, false),
memo: jspb.Message.getFieldWithDefault(msg, 6, ""),
createdAt: jspb.Message.getFieldWithDefault(msg, 7, 0),
updatedAt: jspb.Message.getFieldWithDefault(msg, 8, 0)
};
if (includeInstance) {
obj.$jspbMessageInstance = msg;
}
return obj;
};
}
/**
* Deserializes binary data (in protobuf wire format).
* @param {jspb.ByteSource} bytes The bytes to deserialize.
* @return {!proto.bet.beteran.bank.Bank}
*/
proto.bet.beteran.bank.Bank.deserializeBinary = function(bytes) {
var reader = new jspb.BinaryReader(bytes);
var msg = new proto.bet.beteran.bank.Bank;
return proto.bet.beteran.bank.Bank.deserializeBinaryFromReader(msg, reader);
};
/**
* Deserializes binary data (in protobuf wire format) from the
* given reader into the given message object.
* @param {!proto.bet.beteran.bank.Bank} msg The message object to deserialize into.
* @param {!jspb.BinaryReader} reader The BinaryReader to use.
* @return {!proto.bet.beteran.bank.Bank}
*/
proto.bet.beteran.bank.Bank.deserializeBinaryFromReader = function(msg, reader) {
while (reader.nextField()) {
if (reader.isEndGroup()) {
break;
}
var field = reader.getFieldNumber();
switch (field) {
case 1:
var value = /** @type {string} */ (reader.readString());
msg.setId(value);
break;
case 2:
var value = /** @type {string} */ (reader.readString());
msg.setName(value);
break;
case 3:
var value = /** @type {number} */ (reader.readUint32());
msg.setSortOrder(value);
break;
case 4:
var value = /** @type {boolean} */ (reader.readBool());
msg.setShow(value);
break;
case 5:
var value = /** @type {boolean} */ (reader.readBool());
msg.setCanUse(value);
break;
case 6:
var value = /** @type {string} */ (reader.readString());
msg.setMemo(value);
break;
case 7:
var value = /** @type {number} */ (reader.readUint64());
msg.setCreatedAt(value);
break;
case 8:
var value = /** @type {number} */ (reader.readUint64());
msg.setUpdatedAt(value);
break;
default:
reader.skipField();
break;
}
}
return msg;
};
/**
* Serializes the message to binary data (in protobuf wire format).
* @return {!Uint8Array}
*/
proto.bet.beteran.bank.Bank.prototype.serializeBinary = function() {
var writer = new jspb.BinaryWriter();
proto.bet.beteran.bank.Bank.serializeBinaryToWriter(this, writer);
return writer.getResultBuffer();
};
/**
* Serializes the given message to binary data (in protobuf wire
* format), writing to the given BinaryWriter.
* @param {!proto.bet.beteran.bank.Bank} message
* @param {!jspb.BinaryWriter} writer
* @suppress {unusedLocalVariables} f is only used for nested messages
*/
proto.bet.beteran.bank.Bank.serializeBinaryToWriter = function(message, writer) {
var f = undefined;
f = message.getId();
if (f.length > 0) {
writer.writeString(
1,
f
);
}
f = message.getName();
if (f.length > 0) {
writer.writeString(
2,
f
);
}
f = message.getSortOrder();
if (f !== 0) {
writer.writeUint32(
3,
f
);
}
f = message.getShow();
if (f) {
writer.writeBool(
4,
f
);
}
f = message.getCanUse();
if (f) {
writer.writeBool(
5,
f
);
}
f = /** @type {string} */ (jspb.Message.getField(message, 6));
if (f != null) {
writer.writeString(
6,
f
);
}
f = message.getCreatedAt();
if (f !== 0) {
writer.writeUint64(
7,
f
);
}
f = message.getUpdatedAt();
if (f !== 0) {
writer.writeUint64(
8,
f
);
}
};
/**
* optional string id = 1;
* @return {string}
*/
proto.bet.beteran.bank.Bank.prototype.getId = function() {
return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, ""));
};
/**
* @param {string} value
* @return {!proto.bet.beteran.bank.Bank} returns this
*/
proto.bet.beteran.bank.Bank.prototype.setId = function(value) {
return jspb.Message.setProto3StringField(this, 1, value);
};
/**
* optional string name = 2;
* @return {string}
*/
proto.bet.beteran.bank.Bank.prototype.getName = function() {
return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 2, ""));
};
/**
* @param {string} value
* @return {!proto.bet.beteran.bank.Bank} returns this
*/
proto.bet.beteran.bank.Bank.prototype.setName = function(value) {
return jspb.Message.setProto3StringField(this, 2, value);
};
/**
* optional uint32 sort_order = 3;
* @return {number}
*/
proto.bet.beteran.bank.Bank.prototype.getSortOrder = function() {
return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 3, 0));
};
/**
* @param {number} value
* @return {!proto.bet.beteran.bank.Bank} returns this
*/
proto.bet.beteran.bank.Bank.prototype.setSortOrder = function(value) {
return jspb.Message.setProto3IntField(this, 3, value);
};
/**
* optional bool show = 4;
* @return {boolean}
*/
proto.bet.beteran.bank.Bank.prototype.getShow = function() {
return /** @type {boolean} */ (jspb.Message.getBooleanFieldWithDefault(this, 4, false));
};
/**
* @param {boolean} value
* @return {!proto.bet.beteran.bank.Bank} returns this
*/
proto.bet.beteran.bank.Bank.prototype.setShow = function(value) {
return jspb.Message.setProto3BooleanField(this, 4, value);
};
/**
* optional bool can_use = 5;
* @return {boolean}
*/
proto.bet.beteran.bank.Bank.prototype.getCanUse = function() {
return /** @type {boolean} */ (jspb.Message.getBooleanFieldWithDefault(this, 5, false));
};
/**
* @param {boolean} value
* @return {!proto.bet.beteran.bank.Bank} returns this
*/
proto.bet.beteran.bank.Bank.prototype.setCanUse = function(value) {
return jspb.Message.setProto3BooleanField(this, 5, value);
};
/**
* optional string memo = 6;
* @return {string}
*/
proto.bet.beteran.bank.Bank.prototype.getMemo = function() {
return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 6, ""));
};
/**
* @param {string} value
* @return {!proto.bet.beteran.bank.Bank} returns this
*/
proto.bet.beteran.bank.Bank.prototype.setMemo = function(value) {
return jspb.Message.setField(this, 6, value);
};
/**
* Clears the field making it undefined.
* @return {!proto.bet.beteran.bank.Bank} returns this
*/
proto.bet.beteran.bank.Bank.prototype.clearMemo = function() {
return jspb.Message.setField(this, 6, undefined);
};
/**
* Returns whether this field is set.
* @return {boolean}
*/
proto.bet.beteran.bank.Bank.prototype.hasMemo = function() {
return jspb.Message.getField(this, 6) != null;
};
/**
* optional uint64 created_at = 7;
* @return {number}
*/
proto.bet.beteran.bank.Bank.prototype.getCreatedAt = function() {
return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 7, 0));
};
/**
* @param {number} value
* @return {!proto.bet.beteran.bank.Bank} returns this
*/
proto.bet.beteran.bank.Bank.prototype.setCreatedAt = function(value) {
return jspb.Message.setProto3IntField(this, 7, value);
};
/**
* optional uint64 updated_at = 8;
* @return {number}
*/
proto.bet.beteran.bank.Bank.prototype.getUpdatedAt = function() {
return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 8, 0));
};
/**
* @param {number} value
* @return {!proto.bet.beteran.bank.Bank} returns this
*/
proto.bet.beteran.bank.Bank.prototype.setUpdatedAt = function(value) {
return jspb.Message.setProto3IntField(this, 8, value);
};
goog.object.extend(exports, proto.bet.beteran.bank);

37
src/app/modules/proto/models/core/network_pb.d.ts vendored Normal file
View File

@ -0,0 +1,37 @@
// package: bet.beteran.core.network
// file: models/core/network.proto
import * as jspb from "google-protobuf";
export class Client extends jspb.Message {
getClientIp(): string;
setClientIp(value: string): void;
hasSiteUrl(): boolean;
clearSiteUrl(): void;
getSiteUrl(): string;
setSiteUrl(value: string): void;
hasAccessToken(): boolean;
clearAccessToken(): void;
getAccessToken(): string;
setAccessToken(value: string): void;
serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): Client.AsObject;
static toObject(includeInstance: boolean, msg: Client): Client.AsObject;
static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
static serializeBinaryToWriter(message: Client, writer: jspb.BinaryWriter): void;
static deserializeBinary(bytes: Uint8Array): Client;
static deserializeBinaryFromReader(message: Client, reader: jspb.BinaryReader): Client;
}
export namespace Client {
export type AsObject = {
clientIp: string,
siteUrl: string,
accessToken: string,
}
}

266
src/app/modules/proto/models/core/network_pb.js Normal file
View File

@ -0,0 +1,266 @@
// source: models/core/network.proto
/**
* @fileoverview
* @enhanceable
* @suppress {missingRequire} reports error on implicit type usages.
* @suppress {messageConventions} JS Compiler reports an error if a variable or
* field starts with 'MSG_' and isn't a translatable message.
* @public
*/
// GENERATED CODE -- DO NOT EDIT!
/* eslint-disable */
// @ts-nocheck
var jspb = require('google-protobuf');
var goog = jspb;
var global = (function() { return this || window || global || self || Function('return this')(); }).call(null);
goog.exportSymbol('proto.bet.beteran.core.network.Client', null, global);
/**
* Generated by JsPbCodeGenerator.
* @param {Array=} opt_data Optional initial data array, typically from a
* server response, or constructed directly in Javascript. The array is used
* in place and becomes part of the constructed object. It is not cloned.
* If no data is provided, the constructed object will be empty, but still
* valid.
* @extends {jspb.Message}
* @constructor
*/
proto.bet.beteran.core.network.Client = function(opt_data) {
jspb.Message.initialize(this, opt_data, 0, -1, null, null);
};
goog.inherits(proto.bet.beteran.core.network.Client, jspb.Message);
if (goog.DEBUG && !COMPILED) {
/**
* @public
* @override
*/
proto.bet.beteran.core.network.Client.displayName = 'proto.bet.beteran.core.network.Client';
}
if (jspb.Message.GENERATE_TO_OBJECT) {
/**
* Creates an object representation of this proto.
* Field names that are reserved in JavaScript and will be renamed to pb_name.
* Optional fields that are not set will be set to undefined.
* To access a reserved field use, foo.pb_<name>, eg, foo.pb_default.
* For the list of reserved names please see:
* net/proto2/compiler/js/internal/generator.cc#kKeyword.
* @param {boolean=} opt_includeInstance Deprecated. whether to include the
* JSPB instance for transitional soy proto support:
* http://goto/soy-param-migration
* @return {!Object}
*/
proto.bet.beteran.core.network.Client.prototype.toObject = function(opt_includeInstance) {
return proto.bet.beteran.core.network.Client.toObject(opt_includeInstance, this);
};
/**
* Static version of the {@see toObject} method.
* @param {boolean|undefined} includeInstance Deprecated. Whether to include
* the JSPB instance for transitional soy proto support:
* http://goto/soy-param-migration
* @param {!proto.bet.beteran.core.network.Client} msg The msg instance to transform.
* @return {!Object}
* @suppress {unusedLocalVariables} f is only used for nested messages
*/
proto.bet.beteran.core.network.Client.toObject = function(includeInstance, msg) {
var f, obj = {
clientIp: jspb.Message.getFieldWithDefault(msg, 1, ""),
siteUrl: jspb.Message.getFieldWithDefault(msg, 2, ""),
accessToken: jspb.Message.getFieldWithDefault(msg, 3, "")
};
if (includeInstance) {
obj.$jspbMessageInstance = msg;
}
return obj;
};
}
/**
* Deserializes binary data (in protobuf wire format).
* @param {jspb.ByteSource} bytes The bytes to deserialize.
* @return {!proto.bet.beteran.core.network.Client}
*/
proto.bet.beteran.core.network.Client.deserializeBinary = function(bytes) {
var reader = new jspb.BinaryReader(bytes);
var msg = new proto.bet.beteran.core.network.Client;
return proto.bet.beteran.core.network.Client.deserializeBinaryFromReader(msg, reader);
};
/**
* Deserializes binary data (in protobuf wire format) from the
* given reader into the given message object.
* @param {!proto.bet.beteran.core.network.Client} msg The message object to deserialize into.
* @param {!jspb.BinaryReader} reader The BinaryReader to use.
* @return {!proto.bet.beteran.core.network.Client}
*/
proto.bet.beteran.core.network.Client.deserializeBinaryFromReader = function(msg, reader) {
while (reader.nextField()) {
if (reader.isEndGroup()) {
break;
}
var field = reader.getFieldNumber();
switch (field) {
case 1:
var value = /** @type {string} */ (reader.readString());
msg.setClientIp(value);
break;
case 2:
var value = /** @type {string} */ (reader.readString());
msg.setSiteUrl(value);
break;
case 3:
var value = /** @type {string} */ (reader.readString());
msg.setAccessToken(value);
break;
default:
reader.skipField();
break;
}
}
return msg;
};
/**
* Serializes the message to binary data (in protobuf wire format).
* @return {!Uint8Array}
*/
proto.bet.beteran.core.network.Client.prototype.serializeBinary = function() {
var writer = new jspb.BinaryWriter();
proto.bet.beteran.core.network.Client.serializeBinaryToWriter(this, writer);
return writer.getResultBuffer();
};
/**
* Serializes the given message to binary data (in protobuf wire
* format), writing to the given BinaryWriter.
* @param {!proto.bet.beteran.core.network.Client} message
* @param {!jspb.BinaryWriter} writer
* @suppress {unusedLocalVariables} f is only used for nested messages
*/
proto.bet.beteran.core.network.Client.serializeBinaryToWriter = function(message, writer) {
var f = undefined;
f = message.getClientIp();
if (f.length > 0) {
writer.writeString(
1,
f
);
}
f = /** @type {string} */ (jspb.Message.getField(message, 2));
if (f != null) {
writer.writeString(
2,
f
);
}
f = /** @type {string} */ (jspb.Message.getField(message, 3));
if (f != null) {
writer.writeString(
3,
f
);
}
};
/**
* optional string client_ip = 1;
* @return {string}
*/
proto.bet.beteran.core.network.Client.prototype.getClientIp = function() {
return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, ""));
};
/**
* @param {string} value
* @return {!proto.bet.beteran.core.network.Client} returns this
*/
proto.bet.beteran.core.network.Client.prototype.setClientIp = function(value) {
return jspb.Message.setProto3StringField(this, 1, value);
};
/**
* optional string site_url = 2;
* @return {string}
*/
proto.bet.beteran.core.network.Client.prototype.getSiteUrl = function() {
return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 2, ""));
};
/**
* @param {string} value
* @return {!proto.bet.beteran.core.network.Client} returns this
*/
proto.bet.beteran.core.network.Client.prototype.setSiteUrl = function(value) {
return jspb.Message.setField(this, 2, value);
};
/**
* Clears the field making it undefined.
* @return {!proto.bet.beteran.core.network.Client} returns this
*/
proto.bet.beteran.core.network.Client.prototype.clearSiteUrl = function() {
return jspb.Message.setField(this, 2, undefined);
};
/**
* Returns whether this field is set.
* @return {boolean}
*/
proto.bet.beteran.core.network.Client.prototype.hasSiteUrl = function() {
return jspb.Message.getField(this, 2) != null;
};
/**
* optional string access_token = 3;
* @return {string}
*/
proto.bet.beteran.core.network.Client.prototype.getAccessToken = function() {
return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 3, ""));
};
/**
* @param {string} value
* @return {!proto.bet.beteran.core.network.Client} returns this
*/
proto.bet.beteran.core.network.Client.prototype.setAccessToken = function(value) {
return jspb.Message.setField(this, 3, value);
};
/**
* Clears the field making it undefined.
* @return {!proto.bet.beteran.core.network.Client} returns this
*/
proto.bet.beteran.core.network.Client.prototype.clearAccessToken = function() {
return jspb.Message.setField(this, 3, undefined);
};
/**
* Returns whether this field is set.
* @return {boolean}
*/
proto.bet.beteran.core.network.Client.prototype.hasAccessToken = function() {
return jspb.Message.getField(this, 3) != null;
};
goog.object.extend(exports, proto.bet.beteran.core.network);

137
src/app/modules/proto/models/member_bank_account_pb.d.ts vendored Normal file
View File

@ -0,0 +1,137 @@
// package: bet.beteran.member_bank_account
// file: models/member_bank_account.proto
import * as jspb from 'google-protobuf';
import * as models_bank_pb from '../models/bank_pb';
export class MemberBankAccount extends jspb.Message {
getId(): string;
setId(value: string): void;
getMemberId(): string;
setMemberId(value: string): void;
getBankId(): string;
setBankId(value: string): void;
getName(): string;
setName(value: string): void;
getAccountNumber(): string;
setAccountNumber(value: string): void;
getExchangePassword(): string;
setExchangePassword(value: string): void;
hasMemo(): boolean;
clearMemo(): void;
getMemo(): string;
setMemo(value: string): void;
getCreatedAt(): number;
setCreatedAt(value: number): void;
getUpdatedAt(): number;
setUpdatedAt(value: number): void;
serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): MemberBankAccount.AsObject;
static toObject(
includeInstance: boolean,
msg: MemberBankAccount
): MemberBankAccount.AsObject;
static extensions: { [key: number]: jspb.ExtensionFieldInfo<jspb.Message> };
static extensionsBinary: {
[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>;
};
static serializeBinaryToWriter(
message: MemberBankAccount,
writer: jspb.BinaryWriter
): void;
static deserializeBinary(bytes: Uint8Array): MemberBankAccount;
static deserializeBinaryFromReader(
message: MemberBankAccount,
reader: jspb.BinaryReader
): MemberBankAccount;
}
export namespace MemberBankAccount {
export type AsObject = {
id: string;
memberId: string;
bankId: string;
name: string;
accountNumber: string;
exchangePassword: string;
memo: string;
createdAt: number;
updatedAt: number;
};
}
export class MemberBankAccountModel extends jspb.Message {
getId(): string;
setId(value: string): void;
getMemberId(): string;
setMemberId(value: string): void;
hasBank(): boolean;
clearBank(): void;
getBank(): models_bank_pb.Bank | undefined;
setBank(value?: models_bank_pb.Bank): void;
getName(): string;
setName(value: string): void;
getAccountNumber(): string;
setAccountNumber(value: string): void;
getExchangePassword(): string;
setExchangePassword(value: string): void;
hasMemo(): boolean;
clearMemo(): void;
getMemo(): string;
setMemo(value: string): void;
getCreatedAt(): number;
setCreatedAt(value: number): void;
getUpdatedAt(): number;
setUpdatedAt(value: number): void;
serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): MemberBankAccountModel.AsObject;
static toObject(
includeInstance: boolean,
msg: MemberBankAccountModel
): MemberBankAccountModel.AsObject;
static extensions: { [key: number]: jspb.ExtensionFieldInfo<jspb.Message> };
static extensionsBinary: {
[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>;
};
static serializeBinaryToWriter(
message: MemberBankAccountModel,
writer: jspb.BinaryWriter
): void;
static deserializeBinary(bytes: Uint8Array): MemberBankAccountModel;
static deserializeBinaryFromReader(
message: MemberBankAccountModel,
reader: jspb.BinaryReader
): MemberBankAccountModel;
}
export namespace MemberBankAccountModel {
export type AsObject = {
id: string;
memberId: string;
bank?: models_bank_pb.Bank.AsObject;
name: string;
accountNumber: string;
exchangePassword: string;
memo: string;
createdAt: number;
updatedAt: number;
};
}

876
src/app/modules/proto/models/member_bank_account_pb.js Normal file
View File

@ -0,0 +1,876 @@
// source: models/member_bank_account.proto
/**
* @fileoverview
* @enhanceable
* @suppress {missingRequire} reports error on implicit type usages.
* @suppress {messageConventions} JS Compiler reports an error if a variable or
* field starts with 'MSG_' and isn't a translatable message.
* @public
*/
// GENERATED CODE -- DO NOT EDIT!
/* eslint-disable */
// @ts-nocheck
var jspb = require("google-protobuf");
var goog = jspb;
var global = function () {
return this || window || global || self || Function("return this")();
}.call(null);
var models_bank_pb = require("../models/bank_pb.js");
goog.object.extend(proto, models_bank_pb);
goog.exportSymbol(
"proto.bet.beteran.member_bank_account.MemberBankAccount",
null,
global
);
goog.exportSymbol(
"proto.bet.beteran.member_bank_account.MemberBankAccountModel",
null,
global
);
/**
* Generated by JsPbCodeGenerator.
* @param {Array=} opt_data Optional initial data array, typically from a
* server response, or constructed directly in Javascript. The array is used
* in place and becomes part of the constructed object. It is not cloned.
* If no data is provided, the constructed object will be empty, but still
* valid.
* @extends {jspb.Message}
* @constructor
*/
proto.bet.beteran.member_bank_account.MemberBankAccount = function (opt_data) {
jspb.Message.initialize(this, opt_data, 0, -1, null, null);
};
goog.inherits(
proto.bet.beteran.member_bank_account.MemberBankAccount,
jspb.Message
);
if (goog.DEBUG && !COMPILED) {
/**
* @public
* @override
*/
proto.bet.beteran.member_bank_account.MemberBankAccount.displayName =
"proto.bet.beteran.member_bank_account.MemberBankAccount";
}
/**
* Generated by JsPbCodeGenerator.
* @param {Array=} opt_data Optional initial data array, typically from a
* server response, or constructed directly in Javascript. The array is used
* in place and becomes part of the constructed object. It is not cloned.
* If no data is provided, the constructed object will be empty, but still
* valid.
* @extends {jspb.Message}
* @constructor
*/
proto.bet.beteran.member_bank_account.MemberBankAccountModel = function (
opt_data
) {
jspb.Message.initialize(this, opt_data, 0, -1, null, null);
};
goog.inherits(
proto.bet.beteran.member_bank_account.MemberBankAccountModel,
jspb.Message
);
if (goog.DEBUG && !COMPILED) {
/**
* @public
* @override
*/
proto.bet.beteran.member_bank_account.MemberBankAccountModel.displayName =
"proto.bet.beteran.member_bank_account.MemberBankAccountModel";
}
if (jspb.Message.GENERATE_TO_OBJECT) {
/**
* Creates an object representation of this proto.
* Field names that are reserved in JavaScript and will be renamed to pb_name.
* Optional fields that are not set will be set to undefined.
* To access a reserved field use, foo.pb_<name>, eg, foo.pb_default.
* For the list of reserved names please see:
* net/proto2/compiler/js/internal/generator.cc#kKeyword.
* @param {boolean=} opt_includeInstance Deprecated. whether to include the
* JSPB instance for transitional soy proto support:
* http://goto/soy-param-migration
* @return {!Object}
*/
proto.bet.beteran.member_bank_account.MemberBankAccount.prototype.toObject =
function (opt_includeInstance) {
return proto.bet.beteran.member_bank_account.MemberBankAccount.toObject(
opt_includeInstance,
this
);
};
/**
* Static version of the {@see toObject} method.
* @param {boolean|undefined} includeInstance Deprecated. Whether to include
* the JSPB instance for transitional soy proto support:
* http://goto/soy-param-migration
* @param {!proto.bet.beteran.member_bank_account.MemberBankAccount} msg The msg instance to transform.
* @return {!Object}
* @suppress {unusedLocalVariables} f is only used for nested messages
*/
proto.bet.beteran.member_bank_account.MemberBankAccount.toObject = function (
includeInstance,
msg
) {
var f,
obj = {
id: jspb.Message.getFieldWithDefault(msg, 1, ""),
memberId: jspb.Message.getFieldWithDefault(msg, 2, ""),
bankId: jspb.Message.getFieldWithDefault(msg, 3, ""),
name: jspb.Message.getFieldWithDefault(msg, 4, ""),
accountNumber: jspb.Message.getFieldWithDefault(msg, 5, ""),
exchangePassword: jspb.Message.getFieldWithDefault(msg, 6, ""),
memo: jspb.Message.getFieldWithDefault(msg, 7, ""),
createdAt: jspb.Message.getFieldWithDefault(msg, 8, 0),
updatedAt: jspb.Message.getFieldWithDefault(msg, 9, 0),
};
if (includeInstance) {
obj.$jspbMessageInstance = msg;
}
return obj;
};
}
/**
* Deserializes binary data (in protobuf wire format).
* @param {jspb.ByteSource} bytes The bytes to deserialize.
* @return {!proto.bet.beteran.member_bank_account.MemberBankAccount}
*/
proto.bet.beteran.member_bank_account.MemberBankAccount.deserializeBinary =
function (bytes) {
var reader = new jspb.BinaryReader(bytes);
var msg = new proto.bet.beteran.member_bank_account.MemberBankAccount();
return proto.bet.beteran.member_bank_account.MemberBankAccount.deserializeBinaryFromReader(
msg,
reader
);
};
/**
* Deserializes binary data (in protobuf wire format) from the
* given reader into the given message object.
* @param {!proto.bet.beteran.member_bank_account.MemberBankAccount} msg The message object to deserialize into.
* @param {!jspb.BinaryReader} reader The BinaryReader to use.
* @return {!proto.bet.beteran.member_bank_account.MemberBankAccount}
*/
proto.bet.beteran.member_bank_account.MemberBankAccount.deserializeBinaryFromReader =
function (msg, reader) {
while (reader.nextField()) {
if (reader.isEndGroup()) {
break;
}
var field = reader.getFieldNumber();
switch (field) {
case 1:
var value = /** @type {string} */ (reader.readString());
msg.setId(value);
break;
case 2:
var value = /** @type {string} */ (reader.readString());
msg.setMemberId(value);
break;
case 3:
var value = /** @type {string} */ (reader.readString());
msg.setBankId(value);
break;
case 4:
var value = /** @type {string} */ (reader.readString());
msg.setName(value);
break;
case 5:
var value = /** @type {string} */ (reader.readString());
msg.setAccountNumber(value);
break;
case 6:
var value = /** @type {string} */ (reader.readString());
msg.setExchangePassword(value);
break;
case 7:
var value = /** @type {string} */ (reader.readString());
msg.setMemo(value);
break;
case 8:
var value = /** @type {number} */ (reader.readUint64());
msg.setCreatedAt(value);
break;
case 9:
var value = /** @type {number} */ (reader.readUint64());
msg.setUpdatedAt(value);
break;
default:
reader.skipField();
break;
}
}
return msg;
};
/**
* Serializes the message to binary data (in protobuf wire format).
* @return {!Uint8Array}
*/
proto.bet.beteran.member_bank_account.MemberBankAccount.prototype.serializeBinary =
function () {
var writer = new jspb.BinaryWriter();
proto.bet.beteran.member_bank_account.MemberBankAccount.serializeBinaryToWriter(
this,
writer
);
return writer.getResultBuffer();
};
/**
* Serializes the given message to binary data (in protobuf wire
* format), writing to the given BinaryWriter.
* @param {!proto.bet.beteran.member_bank_account.MemberBankAccount} message
* @param {!jspb.BinaryWriter} writer
* @suppress {unusedLocalVariables} f is only used for nested messages
*/
proto.bet.beteran.member_bank_account.MemberBankAccount.serializeBinaryToWriter =
function (message, writer) {
var f = undefined;
f = message.getId();
if (f.length > 0) {
writer.writeString(1, f);
}
f = message.getMemberId();
if (f.length > 0) {
writer.writeString(2, f);
}
f = message.getBankId();
if (f.length > 0) {
writer.writeString(3, f);
}
f = message.getName();
if (f.length > 0) {
writer.writeString(4, f);
}
f = message.getAccountNumber();
if (f.length > 0) {
writer.writeString(5, f);
}
f = message.getExchangePassword();
if (f.length > 0) {
writer.writeString(6, f);
}
f = /** @type {string} */ (jspb.Message.getField(message, 7));
if (f != null) {
writer.writeString(7, f);
}
f = message.getCreatedAt();
if (f !== 0) {
writer.writeUint64(8, f);
}
f = message.getUpdatedAt();
if (f !== 0) {
writer.writeUint64(9, f);
}
};
/**
* optional string id = 1;
* @return {string}
*/
proto.bet.beteran.member_bank_account.MemberBankAccount.prototype.getId =
function () {
return /** @type {string} */ (
jspb.Message.getFieldWithDefault(this, 1, "")
);
};
/**
* @param {string} value
* @return {!proto.bet.beteran.member_bank_account.MemberBankAccount} returns this
*/
proto.bet.beteran.member_bank_account.MemberBankAccount.prototype.setId =
function (value) {
return jspb.Message.setProto3StringField(this, 1, value);
};
/**
* optional string member_id = 2;
* @return {string}
*/
proto.bet.beteran.member_bank_account.MemberBankAccount.prototype.getMemberId =
function () {
return /** @type {string} */ (
jspb.Message.getFieldWithDefault(this, 2, "")
);
};
/**
* @param {string} value
* @return {!proto.bet.beteran.member_bank_account.MemberBankAccount} returns this
*/
proto.bet.beteran.member_bank_account.MemberBankAccount.prototype.setMemberId =
function (value) {
return jspb.Message.setProto3StringField(this, 2, value);
};
/**
* optional string bank_id = 3;
* @return {string}
*/
proto.bet.beteran.member_bank_account.MemberBankAccount.prototype.getBankId =
function () {
return /** @type {string} */ (
jspb.Message.getFieldWithDefault(this, 3, "")
);
};
/**
* @param {string} value
* @return {!proto.bet.beteran.member_bank_account.MemberBankAccount} returns this
*/
proto.bet.beteran.member_bank_account.MemberBankAccount.prototype.setBankId =
function (value) {
return jspb.Message.setProto3StringField(this, 3, value);
};
/**
* optional string name = 4;
* @return {string}
*/
proto.bet.beteran.member_bank_account.MemberBankAccount.prototype.getName =
function () {
return /** @type {string} */ (
jspb.Message.getFieldWithDefault(this, 4, "")
);
};
/**
* @param {string} value
* @return {!proto.bet.beteran.member_bank_account.MemberBankAccount} returns this
*/
proto.bet.beteran.member_bank_account.MemberBankAccount.prototype.setName =
function (value) {
return jspb.Message.setProto3StringField(this, 4, value);
};
/**
* optional string account_number = 5;
* @return {string}
*/
proto.bet.beteran.member_bank_account.MemberBankAccount.prototype.getAccountNumber =
function () {
return /** @type {string} */ (
jspb.Message.getFieldWithDefault(this, 5, "")
);
};
/**
* @param {string} value
* @return {!proto.bet.beteran.member_bank_account.MemberBankAccount} returns this
*/
proto.bet.beteran.member_bank_account.MemberBankAccount.prototype.setAccountNumber =
function (value) {
return jspb.Message.setProto3StringField(this, 5, value);
};
/**
* optional string exchange_password = 6;
* @return {string}
*/
proto.bet.beteran.member_bank_account.MemberBankAccount.prototype.getExchangePassword =
function () {
return /** @type {string} */ (
jspb.Message.getFieldWithDefault(this, 6, "")
);
};
/**
* @param {string} value
* @return {!proto.bet.beteran.member_bank_account.MemberBankAccount} returns this
*/
proto.bet.beteran.member_bank_account.MemberBankAccount.prototype.setExchangePassword =
function (value) {
return jspb.Message.setProto3StringField(this, 6, value);
};
/**
* optional string memo = 7;
* @return {string}
*/
proto.bet.beteran.member_bank_account.MemberBankAccount.prototype.getMemo =
function () {
return /** @type {string} */ (
jspb.Message.getFieldWithDefault(this, 7, "")
);
};
/**
* @param {string} value
* @return {!proto.bet.beteran.member_bank_account.MemberBankAccount} returns this
*/
proto.bet.beteran.member_bank_account.MemberBankAccount.prototype.setMemo =
function (value) {
return jspb.Message.setField(this, 7, value);
};
/**
* Clears the field making it undefined.
* @return {!proto.bet.beteran.member_bank_account.MemberBankAccount} returns this
*/
proto.bet.beteran.member_bank_account.MemberBankAccount.prototype.clearMemo =
function () {
return jspb.Message.setField(this, 7, undefined);
};
/**
* Returns whether this field is set.
* @return {boolean}
*/
proto.bet.beteran.member_bank_account.MemberBankAccount.prototype.hasMemo =
function () {
return jspb.Message.getField(this, 7) != null;
};
/**
* optional uint64 created_at = 8;
* @return {number}
*/
proto.bet.beteran.member_bank_account.MemberBankAccount.prototype.getCreatedAt =
function () {
return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 8, 0));
};
/**
* @param {number} value
* @return {!proto.bet.beteran.member_bank_account.MemberBankAccount} returns this
*/
proto.bet.beteran.member_bank_account.MemberBankAccount.prototype.setCreatedAt =
function (value) {
return jspb.Message.setProto3IntField(this, 8, value);
};
/**
* optional uint64 updated_at = 9;
* @return {number}
*/
proto.bet.beteran.member_bank_account.MemberBankAccount.prototype.getUpdatedAt =
function () {
return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 9, 0));
};
/**
* @param {number} value
* @return {!proto.bet.beteran.member_bank_account.MemberBankAccount} returns this
*/
proto.bet.beteran.member_bank_account.MemberBankAccount.prototype.setUpdatedAt =
function (value) {
return jspb.Message.setProto3IntField(this, 9, value);
};
if (jspb.Message.GENERATE_TO_OBJECT) {
/**
* Creates an object representation of this proto.
* Field names that are reserved in JavaScript and will be renamed to pb_name.
* Optional fields that are not set will be set to undefined.
* To access a reserved field use, foo.pb_<name>, eg, foo.pb_default.
* For the list of reserved names please see:
* net/proto2/compiler/js/internal/generator.cc#kKeyword.
* @param {boolean=} opt_includeInstance Deprecated. whether to include the
* JSPB instance for transitional soy proto support:
* http://goto/soy-param-migration
* @return {!Object}
*/
proto.bet.beteran.member_bank_account.MemberBankAccountModel.prototype.toObject =
function (opt_includeInstance) {
return proto.bet.beteran.member_bank_account.MemberBankAccountModel.toObject(
opt_includeInstance,
this
);
};
/**
* Static version of the {@see toObject} method.
* @param {boolean|undefined} includeInstance Deprecated. Whether to include
* the JSPB instance for transitional soy proto support:
* http://goto/soy-param-migration
* @param {!proto.bet.beteran.member_bank_account.MemberBankAccountModel} msg The msg instance to transform.
* @return {!Object}
* @suppress {unusedLocalVariables} f is only used for nested messages
*/
proto.bet.beteran.member_bank_account.MemberBankAccountModel.toObject =
function (includeInstance, msg) {
var f,
obj = {
id: jspb.Message.getFieldWithDefault(msg, 1, ""),
memberId: jspb.Message.getFieldWithDefault(msg, 2, ""),
bank:
(f = msg.getBank()) &&
models_bank_pb.Bank.toObject(includeInstance, f),
name: jspb.Message.getFieldWithDefault(msg, 4, ""),
accountNumber: jspb.Message.getFieldWithDefault(msg, 5, ""),
exchangePassword: jspb.Message.getFieldWithDefault(msg, 6, ""),
memo: jspb.Message.getFieldWithDefault(msg, 7, ""),
createdAt: jspb.Message.getFieldWithDefault(msg, 8, 0),
updatedAt: jspb.Message.getFieldWithDefault(msg, 9, 0),
};
if (includeInstance) {
obj.$jspbMessageInstance = msg;
}
return obj;
};
}
/**
* Deserializes binary data (in protobuf wire format).
* @param {jspb.ByteSource} bytes The bytes to deserialize.
* @return {!proto.bet.beteran.member_bank_account.MemberBankAccountModel}
*/
proto.bet.beteran.member_bank_account.MemberBankAccountModel.deserializeBinary =
function (bytes) {
var reader = new jspb.BinaryReader(bytes);
var msg =
new proto.bet.beteran.member_bank_account.MemberBankAccountModel();
return proto.bet.beteran.member_bank_account.MemberBankAccountModel.deserializeBinaryFromReader(
msg,
reader
);
};
/**
* Deserializes binary data (in protobuf wire format) from the
* given reader into the given message object.
* @param {!proto.bet.beteran.member_bank_account.MemberBankAccountModel} msg The message object to deserialize into.
* @param {!jspb.BinaryReader} reader The BinaryReader to use.
* @return {!proto.bet.beteran.member_bank_account.MemberBankAccountModel}
*/
proto.bet.beteran.member_bank_account.MemberBankAccountModel.deserializeBinaryFromReader =
function (msg, reader) {
while (reader.nextField()) {
if (reader.isEndGroup()) {
break;
}
var field = reader.getFieldNumber();
switch (field) {
case 1:
var value = /** @type {string} */ (reader.readString());
msg.setId(value);
break;
case 2:
var value = /** @type {string} */ (reader.readString());
msg.setMemberId(value);
break;
case 3:
var value = new models_bank_pb.Bank();
reader.readMessage(
value,
models_bank_pb.Bank.deserializeBinaryFromReader
);
msg.setBank(value);
break;
case 4:
var value = /** @type {string} */ (reader.readString());
msg.setName(value);
break;
case 5:
var value = /** @type {string} */ (reader.readString());
msg.setAccountNumber(value);
break;
case 6:
var value = /** @type {string} */ (reader.readString());
msg.setExchangePassword(value);
break;
case 7:
var value = /** @type {string} */ (reader.readString());
msg.setMemo(value);
break;
case 8:
var value = /** @type {number} */ (reader.readUint64());
msg.setCreatedAt(value);
break;
case 9:
var value = /** @type {number} */ (reader.readUint64());
msg.setUpdatedAt(value);
break;
default:
reader.skipField();
break;
}
}
return msg;
};
/**
* Serializes the message to binary data (in protobuf wire format).
* @return {!Uint8Array}
*/
proto.bet.beteran.member_bank_account.MemberBankAccountModel.prototype.serializeBinary =
function () {
var writer = new jspb.BinaryWriter();
proto.bet.beteran.member_bank_account.MemberBankAccountModel.serializeBinaryToWriter(
this,
writer
);
return writer.getResultBuffer();
};
/**
* Serializes the given message to binary data (in protobuf wire
* format), writing to the given BinaryWriter.
* @param {!proto.bet.beteran.member_bank_account.MemberBankAccountModel} message
* @param {!jspb.BinaryWriter} writer
* @suppress {unusedLocalVariables} f is only used for nested messages
*/
proto.bet.beteran.member_bank_account.MemberBankAccountModel.serializeBinaryToWriter =
function (message, writer) {
var f = undefined;
f = message.getId();
if (f.length > 0) {
writer.writeString(1, f);
}
f = message.getMemberId();
if (f.length > 0) {
writer.writeString(2, f);
}
f = message.getBank();
if (f != null) {
writer.writeMessage(3, f, models_bank_pb.Bank.serializeBinaryToWriter);
}
f = message.getName();
if (f.length > 0) {
writer.writeString(4, f);
}
f = message.getAccountNumber();
if (f.length > 0) {
writer.writeString(5, f);
}
f = message.getExchangePassword();
if (f.length > 0) {
writer.writeString(6, f);
}
f = /** @type {string} */ (jspb.Message.getField(message, 7));
if (f != null) {
writer.writeString(7, f);
}
f = message.getCreatedAt();
if (f !== 0) {
writer.writeUint64(8, f);
}
f = message.getUpdatedAt();
if (f !== 0) {
writer.writeUint64(9, f);
}
};
/**
* optional string id = 1;
* @return {string}
*/
proto.bet.beteran.member_bank_account.MemberBankAccountModel.prototype.getId =
function () {
return /** @type {string} */ (
jspb.Message.getFieldWithDefault(this, 1, "")
);
};
/**
* @param {string} value
* @return {!proto.bet.beteran.member_bank_account.MemberBankAccountModel} returns this
*/
proto.bet.beteran.member_bank_account.MemberBankAccountModel.prototype.setId =
function (value) {
return jspb.Message.setProto3StringField(this, 1, value);
};
/**
* optional string member_id = 2;
* @return {string}
*/
proto.bet.beteran.member_bank_account.MemberBankAccountModel.prototype.getMemberId =
function () {
return /** @type {string} */ (
jspb.Message.getFieldWithDefault(this, 2, "")
);
};
/**
* @param {string} value
* @return {!proto.bet.beteran.member_bank_account.MemberBankAccountModel} returns this
*/
proto.bet.beteran.member_bank_account.MemberBankAccountModel.prototype.setMemberId =
function (value) {
return jspb.Message.setProto3StringField(this, 2, value);
};
/**
* optional bet.beteran.bank.Bank bank = 3;
* @return {?proto.bet.beteran.bank.Bank}
*/
proto.bet.beteran.member_bank_account.MemberBankAccountModel.prototype.getBank =
function () {
return /** @type{?proto.bet.beteran.bank.Bank} */ (
jspb.Message.getWrapperField(this, models_bank_pb.Bank, 3)
);
};
/**
* @param {?proto.bet.beteran.bank.Bank|undefined} value
* @return {!proto.bet.beteran.member_bank_account.MemberBankAccountModel} returns this
*/
proto.bet.beteran.member_bank_account.MemberBankAccountModel.prototype.setBank =
function (value) {
return jspb.Message.setWrapperField(this, 3, value);
};
/**
* Clears the message field making it undefined.
* @return {!proto.bet.beteran.member_bank_account.MemberBankAccountModel} returns this
*/
proto.bet.beteran.member_bank_account.MemberBankAccountModel.prototype.clearBank =
function () {
return this.setBank(undefined);
};
/**
* Returns whether this field is set.
* @return {boolean}
*/
proto.bet.beteran.member_bank_account.MemberBankAccountModel.prototype.hasBank =
function () {
return jspb.Message.getField(this, 3) != null;
};
/**
* optional string name = 4;
* @return {string}
*/
proto.bet.beteran.member_bank_account.MemberBankAccountModel.prototype.getName =
function () {
return /** @type {string} */ (
jspb.Message.getFieldWithDefault(this, 4, "")
);
};
/**
* @param {string} value
* @return {!proto.bet.beteran.member_bank_account.MemberBankAccountModel} returns this
*/
proto.bet.beteran.member_bank_account.MemberBankAccountModel.prototype.setName =
function (value) {
return jspb.Message.setProto3StringField(this, 4, value);
};
/**
* optional string account_number = 5;
* @return {string}
*/
proto.bet.beteran.member_bank_account.MemberBankAccountModel.prototype.getAccountNumber =
function () {
return /** @type {string} */ (
jspb.Message.getFieldWithDefault(this, 5, "")
);
};
/**
* @param {string} value
* @return {!proto.bet.beteran.member_bank_account.MemberBankAccountModel} returns this
*/
proto.bet.beteran.member_bank_account.MemberBankAccountModel.prototype.setAccountNumber =
function (value) {
return jspb.Message.setProto3StringField(this, 5, value);
};
/**
* optional string exchange_password = 6;
* @return {string}
*/
proto.bet.beteran.member_bank_account.MemberBankAccountModel.prototype.getExchangePassword =
function () {
return /** @type {string} */ (
jspb.Message.getFieldWithDefault(this, 6, "")
);
};
/**
* @param {string} value
* @return {!proto.bet.beteran.member_bank_account.MemberBankAccountModel} returns this
*/
proto.bet.beteran.member_bank_account.MemberBankAccountModel.prototype.setExchangePassword =
function (value) {
return jspb.Message.setProto3StringField(this, 6, value);
};
/**
* optional string memo = 7;
* @return {string}
*/
proto.bet.beteran.member_bank_account.MemberBankAccountModel.prototype.getMemo =
function () {
return /** @type {string} */ (
jspb.Message.getFieldWithDefault(this, 7, "")
);
};
/**
* @param {string} value
* @return {!proto.bet.beteran.member_bank_account.MemberBankAccountModel} returns this
*/
proto.bet.beteran.member_bank_account.MemberBankAccountModel.prototype.setMemo =
function (value) {
return jspb.Message.setField(this, 7, value);
};
/**
* Clears the field making it undefined.
* @return {!proto.bet.beteran.member_bank_account.MemberBankAccountModel} returns this
*/
proto.bet.beteran.member_bank_account.MemberBankAccountModel.prototype.clearMemo =
function () {
return jspb.Message.setField(this, 7, undefined);
};
/**
* Returns whether this field is set.
* @return {boolean}
*/
proto.bet.beteran.member_bank_account.MemberBankAccountModel.prototype.hasMemo =
function () {
return jspb.Message.getField(this, 7) != null;
};
/**
* optional uint64 created_at = 8;
* @return {number}
*/
proto.bet.beteran.member_bank_account.MemberBankAccountModel.prototype.getCreatedAt =
function () {
return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 8, 0));
};
/**
* @param {number} value
* @return {!proto.bet.beteran.member_bank_account.MemberBankAccountModel} returns this
*/
proto.bet.beteran.member_bank_account.MemberBankAccountModel.prototype.setCreatedAt =
function (value) {
return jspb.Message.setProto3IntField(this, 8, value);
};
/**
* optional uint64 updated_at = 9;
* @return {number}
*/
proto.bet.beteran.member_bank_account.MemberBankAccountModel.prototype.getUpdatedAt =
function () {
return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 9, 0));
};
/**
* @param {number} value
* @return {!proto.bet.beteran.member_bank_account.MemberBankAccountModel} returns this
*/
proto.bet.beteran.member_bank_account.MemberBankAccountModel.prototype.setUpdatedAt =
function (value) {
return jspb.Message.setProto3IntField(this, 9, value);
};
goog.object.extend(exports, proto.bet.beteran.member_bank_account);

67
src/app/modules/proto/models/member_bank_deposit_pb.d.ts vendored Normal file
View File

@ -0,0 +1,67 @@
// package: bet.beteran.member_bank_deposit
// file: models/member_bank_deposit.proto
import * as jspb from "google-protobuf";
export class MemberBankDeposit extends jspb.Message {
getId(): string;
setId(value: string): void;
getMemberId(): string;
setMemberId(value: string): void;
getName(): string;
setName(value: string): void;
getAmount(): number;
setAmount(value: number): void;
hasMemo(): boolean;
clearMemo(): void;
getMemo(): string;
setMemo(value: string): void;
getState(): MemberBankDepositStateMap[keyof MemberBankDepositStateMap];
setState(value: MemberBankDepositStateMap[keyof MemberBankDepositStateMap]): void;
getStateChangedAt(): number;
setStateChangedAt(value: number): void;
getCreatedAt(): number;
setCreatedAt(value: number): void;
getUpdatedAt(): number;
setUpdatedAt(value: number): void;
serializeBinary(): Uint8Array;
toObject(includeInstance?: boolean): MemberBankDeposit.AsObject;
static toObject(includeInstance: boolean, msg: MemberBankDeposit): MemberBankDeposit.AsObject;
static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
static serializeBinaryToWriter(message: MemberBankDeposit, writer: jspb.BinaryWriter): void;
static deserializeBinary(bytes: Uint8Array): MemberBankDeposit;
static deserializeBinaryFromReader(message: MemberBankDeposit, reader: jspb.BinaryReader): MemberBankDeposit;
}
export namespace MemberBankDeposit {
export type AsObject = {
id: string,
memberId: string,
name: string,
amount: number,
memo: string,
state: MemberBankDepositStateMap[keyof MemberBankDepositStateMap],
stateChangedAt: number,
createdAt: number,
updatedAt: number,
}
}
export interface MemberBankDepositStateMap {
NONE: 0;
APPLICATION: 1;
COMPLETE: 2;
}
export const MemberBankDepositState: MemberBankDepositStateMap;

Some files were not shown because too many files have changed in this diff Show More