import * as jspb from 'google-protobuf'



export class Connection extends jspb.Message {
  getId(): string;
  setId(value: string): Connection;

  getHost(): string;
  setHost(value: string): Connection;

  getUser(): string;
  setUser(value: string): Connection;

  getPassword(): string;
  setPassword(value: string): Connection;

  getPort(): number;
  setPort(value: number): Connection;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): Connection.AsObject;
  static toObject(includeInstance: boolean, msg: Connection): Connection.AsObject;
  static serializeBinaryToWriter(message: Connection, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): Connection;
  static deserializeBinaryFromReader(message: Connection, reader: jspb.BinaryReader): Connection;
}

export namespace Connection {
  export type AsObject = {
    id: string,
    host: string,
    user: string,
    password: string,
    port: number,
  }
}

export class CreateConnectionRqst extends jspb.Message {
  getConnection(): Connection | undefined;
  setConnection(value?: Connection): CreateConnectionRqst;
  hasConnection(): boolean;
  clearConnection(): CreateConnectionRqst;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): CreateConnectionRqst.AsObject;
  static toObject(includeInstance: boolean, msg: CreateConnectionRqst): CreateConnectionRqst.AsObject;
  static serializeBinaryToWriter(message: CreateConnectionRqst, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): CreateConnectionRqst;
  static deserializeBinaryFromReader(message: CreateConnectionRqst, reader: jspb.BinaryReader): CreateConnectionRqst;
}

export namespace CreateConnectionRqst {
  export type AsObject = {
    connection?: Connection.AsObject,
  }
}

export class CreateConnectionRsp extends jspb.Message {
  getResult(): boolean;
  setResult(value: boolean): CreateConnectionRsp;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): CreateConnectionRsp.AsObject;
  static toObject(includeInstance: boolean, msg: CreateConnectionRsp): CreateConnectionRsp.AsObject;
  static serializeBinaryToWriter(message: CreateConnectionRsp, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): CreateConnectionRsp;
  static deserializeBinaryFromReader(message: CreateConnectionRsp, reader: jspb.BinaryReader): CreateConnectionRsp;
}

export namespace CreateConnectionRsp {
  export type AsObject = {
    result: boolean,
  }
}

export class DeleteConnectionRqst extends jspb.Message {
  getId(): string;
  setId(value: string): DeleteConnectionRqst;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): DeleteConnectionRqst.AsObject;
  static toObject(includeInstance: boolean, msg: DeleteConnectionRqst): DeleteConnectionRqst.AsObject;
  static serializeBinaryToWriter(message: DeleteConnectionRqst, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): DeleteConnectionRqst;
  static deserializeBinaryFromReader(message: DeleteConnectionRqst, reader: jspb.BinaryReader): DeleteConnectionRqst;
}

export namespace DeleteConnectionRqst {
  export type AsObject = {
    id: string,
  }
}

export class DeleteConnectionRsp extends jspb.Message {
  getResult(): boolean;
  setResult(value: boolean): DeleteConnectionRsp;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): DeleteConnectionRsp.AsObject;
  static toObject(includeInstance: boolean, msg: DeleteConnectionRsp): DeleteConnectionRsp.AsObject;
  static serializeBinaryToWriter(message: DeleteConnectionRsp, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): DeleteConnectionRsp;
  static deserializeBinaryFromReader(message: DeleteConnectionRsp, reader: jspb.BinaryReader): DeleteConnectionRsp;
}

export namespace DeleteConnectionRsp {
  export type AsObject = {
    result: boolean,
  }
}

export class CloseRqst extends jspb.Message {
  getId(): string;
  setId(value: string): CloseRqst;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): CloseRqst.AsObject;
  static toObject(includeInstance: boolean, msg: CloseRqst): CloseRqst.AsObject;
  static serializeBinaryToWriter(message: CloseRqst, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): CloseRqst;
  static deserializeBinaryFromReader(message: CloseRqst, reader: jspb.BinaryReader): CloseRqst;
}

export namespace CloseRqst {
  export type AsObject = {
    id: string,
  }
}

export class CloseRsp extends jspb.Message {
  getResult(): boolean;
  setResult(value: boolean): CloseRsp;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): CloseRsp.AsObject;
  static toObject(includeInstance: boolean, msg: CloseRsp): CloseRsp.AsObject;
  static serializeBinaryToWriter(message: CloseRsp, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): CloseRsp;
  static deserializeBinaryFromReader(message: CloseRsp, reader: jspb.BinaryReader): CloseRsp;
}

export namespace CloseRsp {
  export type AsObject = {
    result: boolean,
  }
}

export class Search extends jspb.Message {
  getId(): string;
  setId(value: string): Search;

  getBasedn(): string;
  setBasedn(value: string): Search;

  getFilter(): string;
  setFilter(value: string): Search;

  getAttributesList(): Array<string>;
  setAttributesList(value: Array<string>): Search;
  clearAttributesList(): Search;
  addAttributes(value: string, index?: number): Search;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): Search.AsObject;
  static toObject(includeInstance: boolean, msg: Search): Search.AsObject;
  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 = {
    id: string,
    basedn: string,
    filter: string,
    attributesList: Array<string>,
  }
}

export class SearchRqst extends jspb.Message {
  getSearch(): Search | undefined;
  setSearch(value?: Search): SearchRqst;
  hasSearch(): boolean;
  clearSearch(): SearchRqst;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): SearchRqst.AsObject;
  static toObject(includeInstance: boolean, msg: SearchRqst): SearchRqst.AsObject;
  static serializeBinaryToWriter(message: SearchRqst, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): SearchRqst;
  static deserializeBinaryFromReader(message: SearchRqst, reader: jspb.BinaryReader): SearchRqst;
}

export namespace SearchRqst {
  export type AsObject = {
    search?: Search.AsObject,
  }
}

export class SearchResp extends jspb.Message {
  getResult(): string;
  setResult(value: string): SearchResp;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): SearchResp.AsObject;
  static toObject(includeInstance: boolean, msg: SearchResp): SearchResp.AsObject;
  static serializeBinaryToWriter(message: SearchResp, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): SearchResp;
  static deserializeBinaryFromReader(message: SearchResp, reader: jspb.BinaryReader): SearchResp;
}

export namespace SearchResp {
  export type AsObject = {
    result: string,
  }
}

export class AuthenticateRqst extends jspb.Message {
  getId(): string;
  setId(value: string): AuthenticateRqst;

  getLogin(): string;
  setLogin(value: string): AuthenticateRqst;

  getPwd(): string;
  setPwd(value: string): AuthenticateRqst;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): AuthenticateRqst.AsObject;
  static toObject(includeInstance: boolean, msg: AuthenticateRqst): AuthenticateRqst.AsObject;
  static serializeBinaryToWriter(message: AuthenticateRqst, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): AuthenticateRqst;
  static deserializeBinaryFromReader(message: AuthenticateRqst, reader: jspb.BinaryReader): AuthenticateRqst;
}

export namespace AuthenticateRqst {
  export type AsObject = {
    id: string,
    login: string,
    pwd: string,
  }
}

export class AuthenticateRsp extends jspb.Message {
  getResult(): boolean;
  setResult(value: boolean): AuthenticateRsp;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): AuthenticateRsp.AsObject;
  static toObject(includeInstance: boolean, msg: AuthenticateRsp): AuthenticateRsp.AsObject;
  static serializeBinaryToWriter(message: AuthenticateRsp, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): AuthenticateRsp;
  static deserializeBinaryFromReader(message: AuthenticateRsp, reader: jspb.BinaryReader): AuthenticateRsp;
}

export namespace AuthenticateRsp {
  export type AsObject = {
    result: boolean,
  }
}

export class StopRequest extends jspb.Message {
  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): StopRequest.AsObject;
  static toObject(includeInstance: boolean, msg: StopRequest): StopRequest.AsObject;
  static serializeBinaryToWriter(message: StopRequest, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): StopRequest;
  static deserializeBinaryFromReader(message: StopRequest, reader: jspb.BinaryReader): StopRequest;
}

export namespace StopRequest {
  export type AsObject = {
  }
}

export class StopResponse extends jspb.Message {
  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): StopResponse.AsObject;
  static toObject(includeInstance: boolean, msg: StopResponse): StopResponse.AsObject;
  static serializeBinaryToWriter(message: StopResponse, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): StopResponse;
  static deserializeBinaryFromReader(message: StopResponse, reader: jspb.BinaryReader): StopResponse;
}

export namespace StopResponse {
  export type AsObject = {
  }
}

export class SynchronizeRequest extends jspb.Message {
  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): SynchronizeRequest.AsObject;
  static toObject(includeInstance: boolean, msg: SynchronizeRequest): SynchronizeRequest.AsObject;
  static serializeBinaryToWriter(message: SynchronizeRequest, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): SynchronizeRequest;
  static deserializeBinaryFromReader(message: SynchronizeRequest, reader: jspb.BinaryReader): SynchronizeRequest;
}

export namespace SynchronizeRequest {
  export type AsObject = {
  }
}

export class SynchronizeResponse extends jspb.Message {
  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): SynchronizeResponse.AsObject;
  static toObject(includeInstance: boolean, msg: SynchronizeResponse): SynchronizeResponse.AsObject;
  static serializeBinaryToWriter(message: SynchronizeResponse, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): SynchronizeResponse;
  static deserializeBinaryFromReader(message: SynchronizeResponse, reader: jspb.BinaryReader): SynchronizeResponse;
}

export namespace SynchronizeResponse {
  export type AsObject = {
  }
}

export class GroupSyncInfo extends jspb.Message {
  getId(): string;
  setId(value: string): GroupSyncInfo;

  getBase(): string;
  setBase(value: string): GroupSyncInfo;

  getQuery(): string;
  setQuery(value: string): GroupSyncInfo;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): GroupSyncInfo.AsObject;
  static toObject(includeInstance: boolean, msg: GroupSyncInfo): GroupSyncInfo.AsObject;
  static serializeBinaryToWriter(message: GroupSyncInfo, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): GroupSyncInfo;
  static deserializeBinaryFromReader(message: GroupSyncInfo, reader: jspb.BinaryReader): GroupSyncInfo;
}

export namespace GroupSyncInfo {
  export type AsObject = {
    id: string,
    base: string,
    query: string,
  }
}

export class UserSyncInfo extends jspb.Message {
  getId(): string;
  setId(value: string): UserSyncInfo;

  getEmail(): string;
  setEmail(value: string): UserSyncInfo;

  getBase(): string;
  setBase(value: string): UserSyncInfo;

  getQuery(): string;
  setQuery(value: string): UserSyncInfo;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): UserSyncInfo.AsObject;
  static toObject(includeInstance: boolean, msg: UserSyncInfo): UserSyncInfo.AsObject;
  static serializeBinaryToWriter(message: UserSyncInfo, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): UserSyncInfo;
  static deserializeBinaryFromReader(message: UserSyncInfo, reader: jspb.BinaryReader): UserSyncInfo;
}

export namespace UserSyncInfo {
  export type AsObject = {
    id: string,
    email: string,
    base: string,
    query: string,
  }
}

export class LdapSyncInfo extends jspb.Message {
  getId(): string;
  setId(value: string): LdapSyncInfo;

  getConnectionid(): string;
  setConnectionid(value: string): LdapSyncInfo;

  getRefresh(): number;
  setRefresh(value: number): LdapSyncInfo;

  getGroupSyncInfo(): GroupSyncInfo | undefined;
  setGroupSyncInfo(value?: GroupSyncInfo): LdapSyncInfo;
  hasGroupSyncInfo(): boolean;
  clearGroupSyncInfo(): LdapSyncInfo;

  getUserSyncInfo(): UserSyncInfo | undefined;
  setUserSyncInfo(value?: UserSyncInfo): LdapSyncInfo;
  hasUserSyncInfo(): boolean;
  clearUserSyncInfo(): LdapSyncInfo;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): LdapSyncInfo.AsObject;
  static toObject(includeInstance: boolean, msg: LdapSyncInfo): LdapSyncInfo.AsObject;
  static serializeBinaryToWriter(message: LdapSyncInfo, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): LdapSyncInfo;
  static deserializeBinaryFromReader(message: LdapSyncInfo, reader: jspb.BinaryReader): LdapSyncInfo;
}

export namespace LdapSyncInfo {
  export type AsObject = {
    id: string,
    connectionid: string,
    refresh: number,
    groupSyncInfo?: GroupSyncInfo.AsObject,
    userSyncInfo?: UserSyncInfo.AsObject,
  }
}

export class setLdapSyncInfoRequest extends jspb.Message {
  getInfo(): LdapSyncInfo | undefined;
  setInfo(value?: LdapSyncInfo): setLdapSyncInfoRequest;
  hasInfo(): boolean;
  clearInfo(): setLdapSyncInfoRequest;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): setLdapSyncInfoRequest.AsObject;
  static toObject(includeInstance: boolean, msg: setLdapSyncInfoRequest): setLdapSyncInfoRequest.AsObject;
  static serializeBinaryToWriter(message: setLdapSyncInfoRequest, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): setLdapSyncInfoRequest;
  static deserializeBinaryFromReader(message: setLdapSyncInfoRequest, reader: jspb.BinaryReader): setLdapSyncInfoRequest;
}

export namespace setLdapSyncInfoRequest {
  export type AsObject = {
    info?: LdapSyncInfo.AsObject,
  }
}

export class setLdapSyncInfoResponse extends jspb.Message {
  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): setLdapSyncInfoResponse.AsObject;
  static toObject(includeInstance: boolean, msg: setLdapSyncInfoResponse): setLdapSyncInfoResponse.AsObject;
  static serializeBinaryToWriter(message: setLdapSyncInfoResponse, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): setLdapSyncInfoResponse;
  static deserializeBinaryFromReader(message: setLdapSyncInfoResponse, reader: jspb.BinaryReader): setLdapSyncInfoResponse;
}

export namespace setLdapSyncInfoResponse {
  export type AsObject = {
  }
}

export class getLdapSyncInfoRequest extends jspb.Message {
  getId(): string;
  setId(value: string): getLdapSyncInfoRequest;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): getLdapSyncInfoRequest.AsObject;
  static toObject(includeInstance: boolean, msg: getLdapSyncInfoRequest): getLdapSyncInfoRequest.AsObject;
  static serializeBinaryToWriter(message: getLdapSyncInfoRequest, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): getLdapSyncInfoRequest;
  static deserializeBinaryFromReader(message: getLdapSyncInfoRequest, reader: jspb.BinaryReader): getLdapSyncInfoRequest;
}

export namespace getLdapSyncInfoRequest {
  export type AsObject = {
    id: string,
  }
}

export class getLdapSyncInfoResponse extends jspb.Message {
  getInfosList(): Array<LdapSyncInfo>;
  setInfosList(value: Array<LdapSyncInfo>): getLdapSyncInfoResponse;
  clearInfosList(): getLdapSyncInfoResponse;
  addInfos(value?: LdapSyncInfo, index?: number): LdapSyncInfo;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): getLdapSyncInfoResponse.AsObject;
  static toObject(includeInstance: boolean, msg: getLdapSyncInfoResponse): getLdapSyncInfoResponse.AsObject;
  static serializeBinaryToWriter(message: getLdapSyncInfoResponse, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): getLdapSyncInfoResponse;
  static deserializeBinaryFromReader(message: getLdapSyncInfoResponse, reader: jspb.BinaryReader): getLdapSyncInfoResponse;
}

export namespace getLdapSyncInfoResponse {
  export type AsObject = {
    infosList: Array<LdapSyncInfo.AsObject>,
  }
}

export class deleteLdapSyncInfoRequest extends jspb.Message {
  getId(): string;
  setId(value: string): deleteLdapSyncInfoRequest;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): deleteLdapSyncInfoRequest.AsObject;
  static toObject(includeInstance: boolean, msg: deleteLdapSyncInfoRequest): deleteLdapSyncInfoRequest.AsObject;
  static serializeBinaryToWriter(message: deleteLdapSyncInfoRequest, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): deleteLdapSyncInfoRequest;
  static deserializeBinaryFromReader(message: deleteLdapSyncInfoRequest, reader: jspb.BinaryReader): deleteLdapSyncInfoRequest;
}

export namespace deleteLdapSyncInfoRequest {
  export type AsObject = {
    id: string,
  }
}

export class deleteLdapSyncInfoResponse extends jspb.Message {
  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): deleteLdapSyncInfoResponse.AsObject;
  static toObject(includeInstance: boolean, msg: deleteLdapSyncInfoResponse): deleteLdapSyncInfoResponse.AsObject;
  static serializeBinaryToWriter(message: deleteLdapSyncInfoResponse, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): deleteLdapSyncInfoResponse;
  static deserializeBinaryFromReader(message: deleteLdapSyncInfoResponse, reader: jspb.BinaryReader): deleteLdapSyncInfoResponse;
}

export namespace deleteLdapSyncInfoResponse {
  export type AsObject = {
  }
}