@acequants/aegis-contracts 0.1.22 → 0.1.24

package/dist/src/gen/auth/v1/auth.d.ts

@@ -0,0 +1,663 @@
+import type { handleUnaryCall, UntypedServiceImplementation } from "@grpc/grpc-js";
+import _m0 from "protobufjs/minimal";
+import { Observable } from "rxjs";
+import { Timestamp } from "../../google/protobuf/timestamp";
+export declare const protobufPackage = "aegis.auth.v1";
+export interface GrpcDtoPagination {
+    totalItems: number;
+    totalPages: number;
+    currentPage: number;
+    pageSize: number;
+}
+export interface GrpcDtoMessage {
+    message: string;
+}
+/** ---- AUTH ---- */
+export interface GrpcDtoService {
+    publicId: string;
+    namespace: string;
+}
+export interface GrpcDtoSession {
+    publicId: string;
+    service?: GrpcDtoService | undefined;
+    user?: GrpcDtoUser | undefined;
+}
+export interface GrpcDtoAuthenticate {
+    valid?: boolean | undefined;
+    reason?: string | undefined;
+    session?: GrpcDtoSession | undefined;
+}
+export interface GrpcDtoAuthorize {
+    allowed: boolean;
+    reason: string;
+}
+export interface GrpcInputAuthenticate {
+    accessToken: string;
+    userAgent: string;
+    ip: string;
+}
+export interface GrpcInputAuthorize {
+}
+/** ---- PERMISSION ---- */
+export interface GrpcInputPermission {
+    publicId: string;
+}
+export interface GrpcInputPermissions {
+    search?: string | undefined;
+    page?: number | undefined;
+    pageSize?: number | undefined;
+    sortBy?: string | undefined;
+    sortOrder?: string | undefined;
+}
+export interface GrpcInputRolePermissions {
+    rolePublicId: string;
+}
+export interface GrpcInputSeedPermission {
+    name: string;
+}
+export interface GrpcInputSeedPermissions {
+    permissions: GrpcInputSeedPermission[];
+}
+export interface GrpcDtoPermission {
+    publicId: string;
+    name: string;
+    description: string;
+    createdAt?: Timestamp | undefined;
+    updatedAt?: Timestamp | undefined;
+    deletedAt?: Timestamp | undefined;
+}
+export interface GrpcDtoPermissions {
+    permissions: GrpcDtoPermission[];
+}
+export interface GrpcDtoRolePermission {
+    publicId: string;
+    permission?: GrpcDtoPermission | undefined;
+    role?: GrpcDtoRole | undefined;
+}
+export interface GrpcDtoRolePermissions {
+    rolePermissions: GrpcDtoRolePermission[];
+}
+export interface GrpcDtoPermissionsPaginated {
+    items: GrpcDtoPermission[];
+    meta?: GrpcDtoPagination | undefined;
+}
+/** ---- ROLE ---- */
+export interface GrpcInputRoles {
+    search?: string | undefined;
+    page: number;
+    pageSize: number;
+    sortBy?: string | undefined;
+    sortOrder?: string | undefined;
+}
+export interface GrpcInputRole {
+    publicId: string;
+}
+export interface GrpcInputRoleCreate {
+    name: string;
+    description?: string | undefined;
+}
+export interface GrpcInputRoleUpdate {
+    publicId: string;
+    name?: string | undefined;
+    description?: string | undefined;
+}
+export interface GrpcInputRoleRecycle {
+    publicIds: string[];
+}
+export interface GrpcInputRoleRestore {
+    publicIds: string[];
+}
+export interface GrpcInputRolePermissionsAdd {
+    publicId: string;
+    permissionIds: string[];
+}
+export interface GrpcInputRolePermissionsRemove {
+    publicRolePermissionIds: string[];
+}
+export interface GrpcDtoRole {
+    publicId: string;
+    name: string;
+    description?: string | undefined;
+    createdAt?: Timestamp | undefined;
+    updatedAt?: Timestamp | undefined;
+    deletedAt?: Timestamp | undefined;
+    permissions: GrpcDtoPermission[];
+    users: GrpcDtoUser[];
+}
+export interface GrpcDtoRoles {
+    items: GrpcDtoRole[];
+    meta?: GrpcDtoPagination | undefined;
+}
+export interface GrpcDtoPermissionsAdd {
+    permissions: GrpcDtoPermission[];
+}
+/** ---- CLIENT TYPE ---- */
+export interface GrpcInputClientTypeSeed {
+    key: string;
+}
+export interface GrpcInputClientTypesSeed {
+    clientTypes: GrpcInputClientTypeSeed[];
+}
+export interface GrpcInputClientType {
+    publicId: string;
+}
+export interface GrpcInputClientTypes {
+    search?: string | undefined;
+    page?: number | undefined;
+    pageSize?: number | undefined;
+    sortBy?: string | undefined;
+    sortOrder?: string | undefined;
+}
+export interface GrpcDtoClientType {
+    publicId: string;
+    name: string;
+    createdAt?: Timestamp | undefined;
+    updatedAt?: Timestamp | undefined;
+    deletedAt?: Timestamp | undefined;
+}
+export interface GrpcDtoClientTypesSeed {
+    clientTypes: GrpcDtoClientType[];
+}
+export interface GrpcDtoClientTypes {
+    items: GrpcDtoClientType[];
+    meta?: GrpcDtoPagination | undefined;
+}
+/** ---- USER TYPE ---- */
+export interface GrpcInputUserAccountTypeSeed {
+    key: string;
+}
+export interface GrpcInputUserAccountTypesSeed {
+    userTypes: GrpcInputUserAccountTypeSeed[];
+}
+export interface GrpcInputUserAccountType {
+    publicId: string;
+}
+export interface GrpcInputUserAccountTypes {
+    search?: string | undefined;
+    page?: number | undefined;
+    pageSize?: number | undefined;
+    sortBy?: string | undefined;
+    sortOrder?: string | undefined;
+}
+export interface GrpcDtoUserAccountType {
+    publicId: string;
+    name: string;
+    createdAt?: Timestamp | undefined;
+    updatedAt?: Timestamp | undefined;
+    deletedAt?: Timestamp | undefined;
+}
+export interface GrpcDtoUserAccountTypesSeed {
+    userTypes: GrpcDtoUserAccountType[];
+}
+export interface GrpcDtoUserAccountTypes {
+    items: GrpcDtoUserAccountType[];
+    meta?: GrpcDtoPagination | undefined;
+}
+/** --- USER --- */
+export interface GrpcDtoUserRole {
+    role?: GrpcDtoRole | undefined;
+}
+export interface GrpcDtoUser {
+    publicId: string;
+    email: string;
+    phone: string;
+    isEmailVerified: boolean;
+    displayName?: string | undefined;
+    createdAt?: Timestamp | undefined;
+    updatedAt?: Timestamp | undefined;
+    deletedAt?: Timestamp | undefined;
+    roles: GrpcDtoUserRole[];
+}
+export declare const AEGIS_AUTH_V1_PACKAGE_NAME = "aegis.auth.v1";
+export declare const GrpcDtoPagination: {
+    encode(message: GrpcDtoPagination, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): GrpcDtoPagination;
+};
+export declare const GrpcDtoMessage: {
+    encode(message: GrpcDtoMessage, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): GrpcDtoMessage;
+};
+export declare const GrpcDtoService: {
+    encode(message: GrpcDtoService, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): GrpcDtoService;
+};
+export declare const GrpcDtoSession: {
+    encode(message: GrpcDtoSession, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): GrpcDtoSession;
+};
+export declare const GrpcDtoAuthenticate: {
+    encode(message: GrpcDtoAuthenticate, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): GrpcDtoAuthenticate;
+};
+export declare const GrpcDtoAuthorize: {
+    encode(message: GrpcDtoAuthorize, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): GrpcDtoAuthorize;
+};
+export declare const GrpcInputAuthenticate: {
+    encode(message: GrpcInputAuthenticate, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): GrpcInputAuthenticate;
+};
+export declare const GrpcInputAuthorize: {
+    encode(_: GrpcInputAuthorize, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): GrpcInputAuthorize;
+};
+export declare const GrpcInputPermission: {
+    encode(message: GrpcInputPermission, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): GrpcInputPermission;
+};
+export declare const GrpcInputPermissions: {
+    encode(message: GrpcInputPermissions, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): GrpcInputPermissions;
+};
+export declare const GrpcInputRolePermissions: {
+    encode(message: GrpcInputRolePermissions, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): GrpcInputRolePermissions;
+};
+export declare const GrpcInputSeedPermission: {
+    encode(message: GrpcInputSeedPermission, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): GrpcInputSeedPermission;
+};
+export declare const GrpcInputSeedPermissions: {
+    encode(message: GrpcInputSeedPermissions, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): GrpcInputSeedPermissions;
+};
+export declare const GrpcDtoPermission: {
+    encode(message: GrpcDtoPermission, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): GrpcDtoPermission;
+};
+export declare const GrpcDtoPermissions: {
+    encode(message: GrpcDtoPermissions, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): GrpcDtoPermissions;
+};
+export declare const GrpcDtoRolePermission: {
+    encode(message: GrpcDtoRolePermission, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): GrpcDtoRolePermission;
+};
+export declare const GrpcDtoRolePermissions: {
+    encode(message: GrpcDtoRolePermissions, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): GrpcDtoRolePermissions;
+};
+export declare const GrpcDtoPermissionsPaginated: {
+    encode(message: GrpcDtoPermissionsPaginated, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): GrpcDtoPermissionsPaginated;
+};
+export declare const GrpcInputRoles: {
+    encode(message: GrpcInputRoles, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): GrpcInputRoles;
+};
+export declare const GrpcInputRole: {
+    encode(message: GrpcInputRole, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): GrpcInputRole;
+};
+export declare const GrpcInputRoleCreate: {
+    encode(message: GrpcInputRoleCreate, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): GrpcInputRoleCreate;
+};
+export declare const GrpcInputRoleUpdate: {
+    encode(message: GrpcInputRoleUpdate, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): GrpcInputRoleUpdate;
+};
+export declare const GrpcInputRoleRecycle: {
+    encode(message: GrpcInputRoleRecycle, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): GrpcInputRoleRecycle;
+};
+export declare const GrpcInputRoleRestore: {
+    encode(message: GrpcInputRoleRestore, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): GrpcInputRoleRestore;
+};
+export declare const GrpcInputRolePermissionsAdd: {
+    encode(message: GrpcInputRolePermissionsAdd, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): GrpcInputRolePermissionsAdd;
+};
+export declare const GrpcInputRolePermissionsRemove: {
+    encode(message: GrpcInputRolePermissionsRemove, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): GrpcInputRolePermissionsRemove;
+};
+export declare const GrpcDtoRole: {
+    encode(message: GrpcDtoRole, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): GrpcDtoRole;
+};
+export declare const GrpcDtoRoles: {
+    encode(message: GrpcDtoRoles, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): GrpcDtoRoles;
+};
+export declare const GrpcDtoPermissionsAdd: {
+    encode(message: GrpcDtoPermissionsAdd, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): GrpcDtoPermissionsAdd;
+};
+export declare const GrpcInputClientTypeSeed: {
+    encode(message: GrpcInputClientTypeSeed, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): GrpcInputClientTypeSeed;
+};
+export declare const GrpcInputClientTypesSeed: {
+    encode(message: GrpcInputClientTypesSeed, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): GrpcInputClientTypesSeed;
+};
+export declare const GrpcInputClientType: {
+    encode(message: GrpcInputClientType, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): GrpcInputClientType;
+};
+export declare const GrpcInputClientTypes: {
+    encode(message: GrpcInputClientTypes, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): GrpcInputClientTypes;
+};
+export declare const GrpcDtoClientType: {
+    encode(message: GrpcDtoClientType, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): GrpcDtoClientType;
+};
+export declare const GrpcDtoClientTypesSeed: {
+    encode(message: GrpcDtoClientTypesSeed, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): GrpcDtoClientTypesSeed;
+};
+export declare const GrpcDtoClientTypes: {
+    encode(message: GrpcDtoClientTypes, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): GrpcDtoClientTypes;
+};
+export declare const GrpcInputUserAccountTypeSeed: {
+    encode(message: GrpcInputUserAccountTypeSeed, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): GrpcInputUserAccountTypeSeed;
+};
+export declare const GrpcInputUserAccountTypesSeed: {
+    encode(message: GrpcInputUserAccountTypesSeed, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): GrpcInputUserAccountTypesSeed;
+};
+export declare const GrpcInputUserAccountType: {
+    encode(message: GrpcInputUserAccountType, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): GrpcInputUserAccountType;
+};
+export declare const GrpcInputUserAccountTypes: {
+    encode(message: GrpcInputUserAccountTypes, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): GrpcInputUserAccountTypes;
+};
+export declare const GrpcDtoUserAccountType: {
+    encode(message: GrpcDtoUserAccountType, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): GrpcDtoUserAccountType;
+};
+export declare const GrpcDtoUserAccountTypesSeed: {
+    encode(message: GrpcDtoUserAccountTypesSeed, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): GrpcDtoUserAccountTypesSeed;
+};
+export declare const GrpcDtoUserAccountTypes: {
+    encode(message: GrpcDtoUserAccountTypes, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): GrpcDtoUserAccountTypes;
+};
+export declare const GrpcDtoUserRole: {
+    encode(message: GrpcDtoUserRole, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): GrpcDtoUserRole;
+};
+export declare const GrpcDtoUser: {
+    encode(message: GrpcDtoUser, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): GrpcDtoUser;
+};
+export interface AuthServiceClient {
+    /** --- authz --- */
+    authenticate(request: GrpcInputAuthenticate): Observable<GrpcDtoAuthenticate>;
+    authorize(request: GrpcInputAuthorize): Observable<GrpcDtoAuthorize>;
+    /** --- permission --- */
+    permissionsSeed(request: GrpcInputSeedPermissions): Observable<GrpcDtoPermissions>;
+    permissions(request: GrpcInputPermissions): Observable<GrpcDtoPermissionsPaginated>;
+    permission(request: GrpcInputPermission): Observable<GrpcDtoPermission>;
+    rolePermissions(request: GrpcInputRolePermissions): Observable<GrpcDtoRolePermissions>;
+    /** --- role --- */
+    roles(request: GrpcInputRoles): Observable<GrpcDtoRoles>;
+    role(request: GrpcInputRole): Observable<GrpcDtoRole>;
+    roleCreate(request: GrpcInputRoleCreate): Observable<GrpcDtoRole>;
+    roleUpdate(request: GrpcInputRoleUpdate): Observable<GrpcDtoRole>;
+    rolesRecycle(request: GrpcInputRoleRecycle): Observable<GrpcDtoMessage>;
+    rolesRestore(request: GrpcInputRoleRestore): Observable<GrpcDtoMessage>;
+    rolePermissionsAdd(request: GrpcInputRolePermissionsAdd): Observable<GrpcDtoPermissionsAdd>;
+    rolePermissionsRemove(request: GrpcInputRolePermissionsRemove): Observable<GrpcDtoMessage>;
+    /** --- Client Type --- */
+    clientTypesSeed(request: GrpcInputClientTypesSeed): Observable<GrpcDtoClientTypesSeed>;
+    clientTypes(request: GrpcInputClientTypes): Observable<GrpcDtoClientTypes>;
+    clientType(request: GrpcInputClientType): Observable<GrpcDtoClientType>;
+    /** --- User Account Type --- */
+    userAccountTypesSeed(request: GrpcInputUserAccountTypesSeed): Observable<GrpcDtoUserAccountTypesSeed>;
+    userAccountTypes(request: GrpcInputUserAccountTypes): Observable<GrpcDtoUserAccountTypes>;
+    userAccountType(request: GrpcInputUserAccountType): Observable<GrpcDtoUserAccountType>;
+}
+export interface AuthServiceController {
+    /** --- authz --- */
+    authenticate(request: GrpcInputAuthenticate): Promise<GrpcDtoAuthenticate> | Observable<GrpcDtoAuthenticate> | GrpcDtoAuthenticate;
+    authorize(request: GrpcInputAuthorize): Promise<GrpcDtoAuthorize> | Observable<GrpcDtoAuthorize> | GrpcDtoAuthorize;
+    /** --- permission --- */
+    permissionsSeed(request: GrpcInputSeedPermissions): Promise<GrpcDtoPermissions> | Observable<GrpcDtoPermissions> | GrpcDtoPermissions;
+    permissions(request: GrpcInputPermissions): Promise<GrpcDtoPermissionsPaginated> | Observable<GrpcDtoPermissionsPaginated> | GrpcDtoPermissionsPaginated;
+    permission(request: GrpcInputPermission): Promise<GrpcDtoPermission> | Observable<GrpcDtoPermission> | GrpcDtoPermission;
+    rolePermissions(request: GrpcInputRolePermissions): Promise<GrpcDtoRolePermissions> | Observable<GrpcDtoRolePermissions> | GrpcDtoRolePermissions;
+    /** --- role --- */
+    roles(request: GrpcInputRoles): Promise<GrpcDtoRoles> | Observable<GrpcDtoRoles> | GrpcDtoRoles;
+    role(request: GrpcInputRole): Promise<GrpcDtoRole> | Observable<GrpcDtoRole> | GrpcDtoRole;
+    roleCreate(request: GrpcInputRoleCreate): Promise<GrpcDtoRole> | Observable<GrpcDtoRole> | GrpcDtoRole;
+    roleUpdate(request: GrpcInputRoleUpdate): Promise<GrpcDtoRole> | Observable<GrpcDtoRole> | GrpcDtoRole;
+    rolesRecycle(request: GrpcInputRoleRecycle): Promise<GrpcDtoMessage> | Observable<GrpcDtoMessage> | GrpcDtoMessage;
+    rolesRestore(request: GrpcInputRoleRestore): Promise<GrpcDtoMessage> | Observable<GrpcDtoMessage> | GrpcDtoMessage;
+    rolePermissionsAdd(request: GrpcInputRolePermissionsAdd): Promise<GrpcDtoPermissionsAdd> | Observable<GrpcDtoPermissionsAdd> | GrpcDtoPermissionsAdd;
+    rolePermissionsRemove(request: GrpcInputRolePermissionsRemove): Promise<GrpcDtoMessage> | Observable<GrpcDtoMessage> | GrpcDtoMessage;
+    /** --- Client Type --- */
+    clientTypesSeed(request: GrpcInputClientTypesSeed): Promise<GrpcDtoClientTypesSeed> | Observable<GrpcDtoClientTypesSeed> | GrpcDtoClientTypesSeed;
+    clientTypes(request: GrpcInputClientTypes): Promise<GrpcDtoClientTypes> | Observable<GrpcDtoClientTypes> | GrpcDtoClientTypes;
+    clientType(request: GrpcInputClientType): Promise<GrpcDtoClientType> | Observable<GrpcDtoClientType> | GrpcDtoClientType;
+    /** --- User Account Type --- */
+    userAccountTypesSeed(request: GrpcInputUserAccountTypesSeed): Promise<GrpcDtoUserAccountTypesSeed> | Observable<GrpcDtoUserAccountTypesSeed> | GrpcDtoUserAccountTypesSeed;
+    userAccountTypes(request: GrpcInputUserAccountTypes): Promise<GrpcDtoUserAccountTypes> | Observable<GrpcDtoUserAccountTypes> | GrpcDtoUserAccountTypes;
+    userAccountType(request: GrpcInputUserAccountType): Promise<GrpcDtoUserAccountType> | Observable<GrpcDtoUserAccountType> | GrpcDtoUserAccountType;
+}
+export declare function AuthServiceControllerMethods(): (constructor: Function) => void;
+export declare const AUTH_SERVICE_NAME = "AuthService";
+export type AuthServiceService = typeof AuthServiceService;
+export declare const AuthServiceService: {
+    /** --- authz --- */
+    readonly authenticate: {
+        readonly path: "/aegis.auth.v1.AuthService/Authenticate";
+        readonly requestStream: false;
+        readonly responseStream: false;
+        readonly requestSerialize: (value: GrpcInputAuthenticate) => Buffer<ArrayBuffer>;
+        readonly requestDeserialize: (value: Buffer) => GrpcInputAuthenticate;
+        readonly responseSerialize: (value: GrpcDtoAuthenticate) => Buffer<ArrayBuffer>;
+        readonly responseDeserialize: (value: Buffer) => GrpcDtoAuthenticate;
+    };
+    readonly authorize: {
+        readonly path: "/aegis.auth.v1.AuthService/Authorize";
+        readonly requestStream: false;
+        readonly responseStream: false;
+        readonly requestSerialize: (value: GrpcInputAuthorize) => Buffer<ArrayBuffer>;
+        readonly requestDeserialize: (value: Buffer) => GrpcInputAuthorize;
+        readonly responseSerialize: (value: GrpcDtoAuthorize) => Buffer<ArrayBuffer>;
+        readonly responseDeserialize: (value: Buffer) => GrpcDtoAuthorize;
+    };
+    /** --- permission --- */
+    readonly permissionsSeed: {
+        readonly path: "/aegis.auth.v1.AuthService/PermissionsSeed";
+        readonly requestStream: false;
+        readonly responseStream: false;
+        readonly requestSerialize: (value: GrpcInputSeedPermissions) => Buffer<ArrayBuffer>;
+        readonly requestDeserialize: (value: Buffer) => GrpcInputSeedPermissions;
+        readonly responseSerialize: (value: GrpcDtoPermissions) => Buffer<ArrayBuffer>;
+        readonly responseDeserialize: (value: Buffer) => GrpcDtoPermissions;
+    };
+    readonly permissions: {
+        readonly path: "/aegis.auth.v1.AuthService/Permissions";
+        readonly requestStream: false;
+        readonly responseStream: false;
+        readonly requestSerialize: (value: GrpcInputPermissions) => Buffer<ArrayBuffer>;
+        readonly requestDeserialize: (value: Buffer) => GrpcInputPermissions;
+        readonly responseSerialize: (value: GrpcDtoPermissionsPaginated) => Buffer<ArrayBuffer>;
+        readonly responseDeserialize: (value: Buffer) => GrpcDtoPermissionsPaginated;
+    };
+    readonly permission: {
+        readonly path: "/aegis.auth.v1.AuthService/Permission";
+        readonly requestStream: false;
+        readonly responseStream: false;
+        readonly requestSerialize: (value: GrpcInputPermission) => Buffer<ArrayBuffer>;
+        readonly requestDeserialize: (value: Buffer) => GrpcInputPermission;
+        readonly responseSerialize: (value: GrpcDtoPermission) => Buffer<ArrayBuffer>;
+        readonly responseDeserialize: (value: Buffer) => GrpcDtoPermission;
+    };
+    readonly rolePermissions: {
+        readonly path: "/aegis.auth.v1.AuthService/RolePermissions";
+        readonly requestStream: false;
+        readonly responseStream: false;
+        readonly requestSerialize: (value: GrpcInputRolePermissions) => Buffer<ArrayBuffer>;
+        readonly requestDeserialize: (value: Buffer) => GrpcInputRolePermissions;
+        readonly responseSerialize: (value: GrpcDtoRolePermissions) => Buffer<ArrayBuffer>;
+        readonly responseDeserialize: (value: Buffer) => GrpcDtoRolePermissions;
+    };
+    /** --- role --- */
+    readonly roles: {
+        readonly path: "/aegis.auth.v1.AuthService/Roles";
+        readonly requestStream: false;
+        readonly responseStream: false;
+        readonly requestSerialize: (value: GrpcInputRoles) => Buffer<ArrayBuffer>;
+        readonly requestDeserialize: (value: Buffer) => GrpcInputRoles;
+        readonly responseSerialize: (value: GrpcDtoRoles) => Buffer<ArrayBuffer>;
+        readonly responseDeserialize: (value: Buffer) => GrpcDtoRoles;
+    };
+    readonly role: {
+        readonly path: "/aegis.auth.v1.AuthService/Role";
+        readonly requestStream: false;
+        readonly responseStream: false;
+        readonly requestSerialize: (value: GrpcInputRole) => Buffer<ArrayBuffer>;
+        readonly requestDeserialize: (value: Buffer) => GrpcInputRole;
+        readonly responseSerialize: (value: GrpcDtoRole) => Buffer<ArrayBuffer>;
+        readonly responseDeserialize: (value: Buffer) => GrpcDtoRole;
+    };
+    readonly roleCreate: {
+        readonly path: "/aegis.auth.v1.AuthService/RoleCreate";
+        readonly requestStream: false;
+        readonly responseStream: false;
+        readonly requestSerialize: (value: GrpcInputRoleCreate) => Buffer<ArrayBuffer>;
+        readonly requestDeserialize: (value: Buffer) => GrpcInputRoleCreate;
+        readonly responseSerialize: (value: GrpcDtoRole) => Buffer<ArrayBuffer>;
+        readonly responseDeserialize: (value: Buffer) => GrpcDtoRole;
+    };
+    readonly roleUpdate: {
+        readonly path: "/aegis.auth.v1.AuthService/RoleUpdate";
+        readonly requestStream: false;
+        readonly responseStream: false;
+        readonly requestSerialize: (value: GrpcInputRoleUpdate) => Buffer<ArrayBuffer>;
+        readonly requestDeserialize: (value: Buffer) => GrpcInputRoleUpdate;
+        readonly responseSerialize: (value: GrpcDtoRole) => Buffer<ArrayBuffer>;
+        readonly responseDeserialize: (value: Buffer) => GrpcDtoRole;
+    };
+    readonly rolesRecycle: {
+        readonly path: "/aegis.auth.v1.AuthService/RolesRecycle";
+        readonly requestStream: false;
+        readonly responseStream: false;
+        readonly requestSerialize: (value: GrpcInputRoleRecycle) => Buffer<ArrayBuffer>;
+        readonly requestDeserialize: (value: Buffer) => GrpcInputRoleRecycle;
+        readonly responseSerialize: (value: GrpcDtoMessage) => Buffer<ArrayBuffer>;
+        readonly responseDeserialize: (value: Buffer) => GrpcDtoMessage;
+    };
+    readonly rolesRestore: {
+        readonly path: "/aegis.auth.v1.AuthService/RolesRestore";
+        readonly requestStream: false;
+        readonly responseStream: false;
+        readonly requestSerialize: (value: GrpcInputRoleRestore) => Buffer<ArrayBuffer>;
+        readonly requestDeserialize: (value: Buffer) => GrpcInputRoleRestore;
+        readonly responseSerialize: (value: GrpcDtoMessage) => Buffer<ArrayBuffer>;
+        readonly responseDeserialize: (value: Buffer) => GrpcDtoMessage;
+    };
+    readonly rolePermissionsAdd: {
+        readonly path: "/aegis.auth.v1.AuthService/RolePermissionsAdd";
+        readonly requestStream: false;
+        readonly responseStream: false;
+        readonly requestSerialize: (value: GrpcInputRolePermissionsAdd) => Buffer<ArrayBuffer>;
+        readonly requestDeserialize: (value: Buffer) => GrpcInputRolePermissionsAdd;
+        readonly responseSerialize: (value: GrpcDtoPermissionsAdd) => Buffer<ArrayBuffer>;
+        readonly responseDeserialize: (value: Buffer) => GrpcDtoPermissionsAdd;
+    };
+    readonly rolePermissionsRemove: {
+        readonly path: "/aegis.auth.v1.AuthService/RolePermissionsRemove";
+        readonly requestStream: false;
+        readonly responseStream: false;
+        readonly requestSerialize: (value: GrpcInputRolePermissionsRemove) => Buffer<ArrayBuffer>;
+        readonly requestDeserialize: (value: Buffer) => GrpcInputRolePermissionsRemove;
+        readonly responseSerialize: (value: GrpcDtoMessage) => Buffer<ArrayBuffer>;
+        readonly responseDeserialize: (value: Buffer) => GrpcDtoMessage;
+    };
+    /** --- Client Type --- */
+    readonly clientTypesSeed: {
+        readonly path: "/aegis.auth.v1.AuthService/ClientTypesSeed";
+        readonly requestStream: false;
+        readonly responseStream: false;
+        readonly requestSerialize: (value: GrpcInputClientTypesSeed) => Buffer<ArrayBuffer>;
+        readonly requestDeserialize: (value: Buffer) => GrpcInputClientTypesSeed;
+        readonly responseSerialize: (value: GrpcDtoClientTypesSeed) => Buffer<ArrayBuffer>;
+        readonly responseDeserialize: (value: Buffer) => GrpcDtoClientTypesSeed;
+    };
+    readonly clientTypes: {
+        readonly path: "/aegis.auth.v1.AuthService/ClientTypes";
+        readonly requestStream: false;
+        readonly responseStream: false;
+        readonly requestSerialize: (value: GrpcInputClientTypes) => Buffer<ArrayBuffer>;
+        readonly requestDeserialize: (value: Buffer) => GrpcInputClientTypes;
+        readonly responseSerialize: (value: GrpcDtoClientTypes) => Buffer<ArrayBuffer>;
+        readonly responseDeserialize: (value: Buffer) => GrpcDtoClientTypes;
+    };
+    readonly clientType: {
+        readonly path: "/aegis.auth.v1.AuthService/ClientType";
+        readonly requestStream: false;
+        readonly responseStream: false;
+        readonly requestSerialize: (value: GrpcInputClientType) => Buffer<ArrayBuffer>;
+        readonly requestDeserialize: (value: Buffer) => GrpcInputClientType;
+        readonly responseSerialize: (value: GrpcDtoClientType) => Buffer<ArrayBuffer>;
+        readonly responseDeserialize: (value: Buffer) => GrpcDtoClientType;
+    };
+    /** --- User Account Type --- */
+    readonly userAccountTypesSeed: {
+        readonly path: "/aegis.auth.v1.AuthService/UserAccountTypesSeed";
+        readonly requestStream: false;
+        readonly responseStream: false;
+        readonly requestSerialize: (value: GrpcInputUserAccountTypesSeed) => Buffer<ArrayBuffer>;
+        readonly requestDeserialize: (value: Buffer) => GrpcInputUserAccountTypesSeed;
+        readonly responseSerialize: (value: GrpcDtoUserAccountTypesSeed) => Buffer<ArrayBuffer>;
+        readonly responseDeserialize: (value: Buffer) => GrpcDtoUserAccountTypesSeed;
+    };
+    readonly userAccountTypes: {
+        readonly path: "/aegis.auth.v1.AuthService/UserAccountTypes";
+        readonly requestStream: false;
+        readonly responseStream: false;
+        readonly requestSerialize: (value: GrpcInputUserAccountTypes) => Buffer<ArrayBuffer>;
+        readonly requestDeserialize: (value: Buffer) => GrpcInputUserAccountTypes;
+        readonly responseSerialize: (value: GrpcDtoUserAccountTypes) => Buffer<ArrayBuffer>;
+        readonly responseDeserialize: (value: Buffer) => GrpcDtoUserAccountTypes;
+    };
+    readonly userAccountType: {
+        readonly path: "/aegis.auth.v1.AuthService/UserAccountType";
+        readonly requestStream: false;
+        readonly responseStream: false;
+        readonly requestSerialize: (value: GrpcInputUserAccountType) => Buffer<ArrayBuffer>;
+        readonly requestDeserialize: (value: Buffer) => GrpcInputUserAccountType;
+        readonly responseSerialize: (value: GrpcDtoUserAccountType) => Buffer<ArrayBuffer>;
+        readonly responseDeserialize: (value: Buffer) => GrpcDtoUserAccountType;
+    };
+};
+export interface AuthServiceServer extends UntypedServiceImplementation {
+    /** --- authz --- */
+    authenticate: handleUnaryCall<GrpcInputAuthenticate, GrpcDtoAuthenticate>;
+    authorize: handleUnaryCall<GrpcInputAuthorize, GrpcDtoAuthorize>;
+    /** --- permission --- */
+    permissionsSeed: handleUnaryCall<GrpcInputSeedPermissions, GrpcDtoPermissions>;
+    permissions: handleUnaryCall<GrpcInputPermissions, GrpcDtoPermissionsPaginated>;
+    permission: handleUnaryCall<GrpcInputPermission, GrpcDtoPermission>;
+    rolePermissions: handleUnaryCall<GrpcInputRolePermissions, GrpcDtoRolePermissions>;
+    /** --- role --- */
+    roles: handleUnaryCall<GrpcInputRoles, GrpcDtoRoles>;
+    role: handleUnaryCall<GrpcInputRole, GrpcDtoRole>;
+    roleCreate: handleUnaryCall<GrpcInputRoleCreate, GrpcDtoRole>;
+    roleUpdate: handleUnaryCall<GrpcInputRoleUpdate, GrpcDtoRole>;
+    rolesRecycle: handleUnaryCall<GrpcInputRoleRecycle, GrpcDtoMessage>;
+    rolesRestore: handleUnaryCall<GrpcInputRoleRestore, GrpcDtoMessage>;
+    rolePermissionsAdd: handleUnaryCall<GrpcInputRolePermissionsAdd, GrpcDtoPermissionsAdd>;
+    rolePermissionsRemove: handleUnaryCall<GrpcInputRolePermissionsRemove, GrpcDtoMessage>;
+    /** --- Client Type --- */
+    clientTypesSeed: handleUnaryCall<GrpcInputClientTypesSeed, GrpcDtoClientTypesSeed>;
+    clientTypes: handleUnaryCall<GrpcInputClientTypes, GrpcDtoClientTypes>;
+    clientType: handleUnaryCall<GrpcInputClientType, GrpcDtoClientType>;
+    /** --- User Account Type --- */
+    userAccountTypesSeed: handleUnaryCall<GrpcInputUserAccountTypesSeed, GrpcDtoUserAccountTypesSeed>;
+    userAccountTypes: handleUnaryCall<GrpcInputUserAccountTypes, GrpcDtoUserAccountTypes>;
+    userAccountType: handleUnaryCall<GrpcInputUserAccountType, GrpcDtoUserAccountType>;
+}
+//# sourceMappingURL=auth.d.ts.map