import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire";
import Long from "long";
import type { CallContext, CallOptions } from "nice-grpc-common";
import { PaginationRequest, PaginationResponse } from "../../filter/v2/filter.js";
import { FieldName, Group, GroupsSearchFilter, GroupUser, GroupUserFieldName, GroupUsersSearchFilter } from "./group.js";
export declare const protobufPackage = "zitadel.group.v2";
export interface CreateGroupRequest {
    /** The ID of the Organization where the group should be created. */
    organizationId: string;
    /** Name of the group. This must be unique inside the corresponding organization. */
    name: string;
    /** Optionally, provide a description of the group that could help others identify its purpose. */
    description: string;
    /**
     * In case you need to specify the unique identifier of the group, such as to recreate a previously existing group, you can provide the ID.
     * If omitted, the system will generate an ID for you.
     * This is the preferred way. The generated ID will be returned in the response.
     */
    id?: string | undefined;
}
export interface CreateGroupResponse {
    /** ID is the unique identifier of the newly created user group. */
    id: string;
    /** CreationDate is the timestamp when the user group was created. */
    creationDate: Date | undefined;
}
export interface ListGroupsRequest {
    /** Criteria to list the user groups. */
    filters: GroupsSearchFilter[];
    /** Pagination and sorting. */
    pagination: PaginationRequest | undefined;
    /** The field the result is sorted by. */
    sortingColumn?: FieldName | undefined;
}
export interface ListGroupsResponse {
    /** The list of groups. */
    groups: Group[];
    /** Contains the total number of groups matching the query and the applied limit. */
    pagination: PaginationResponse | undefined;
}
export interface GetGroupRequest {
    /** The ID of the group to be retrieved. */
    id: string;
}
export interface GetGroupResponse {
    group: Group | undefined;
}
export interface UpdateGroupRequest {
    /** The ID of the user group to be updated. */
    id: string;
    /**
     * Name of the group. The name must be unique inside the corresponding organization.
     * If omitted, the name will be unchanged.
     */
    name?: string | undefined;
    /**
     * Optionally, provide a new description of the group that could help others identify its purpose.
     * If omitted, the description will be unchanged.
     */
    description?: string | undefined;
}
export interface UpdateGroupResponse {
    changeDate: Date | undefined;
}
export interface DeleteGroupRequest {
    /** ID of the user group to be deleted. */
    id: string;
}
export interface DeleteGroupResponse {
    deletionDate: Date | undefined;
}
export interface AddUsersToGroupRequest {
    /** ID of the group to which the users should be added. */
    id: string;
    /** UserIds is a list of IDs of the users who should be added to the group. */
    userIds: string[];
}
export interface AddUsersToGroupResponse {
    /** ChangeDate is the timestamp when the users are added. */
    changeDate: Date | undefined;
}
export interface RemoveUsersFromGroupRequest {
    /** ID of the group from which the users should be removed. */
    id: string;
    /** UserIds is a list of IDs of the users who should be removed the group. */
    userIds: string[];
}
export interface RemoveUsersFromGroupResponse {
    /** ChangeDate is the timestamp when the users are removed. */
    changeDate: Date | undefined;
}
export interface ListGroupUsersRequest {
    /** GroupUsersSearchFilter defines the criteria to list the user groups. */
    filters: GroupUsersSearchFilter[];
    /** Pagination and sorting. */
    pagination: PaginationRequest | undefined;
    /** SortingColumn defines the field the result is sorted by. */
    sortingColumn?: GroupUserFieldName | undefined;
}
export interface ListGroupUsersResponse {
    /** GroupUsers is the list of users present in the requested group, matching the search criteria */
    groupUsers: GroupUser[];
    /** Contains the total number of users matching the query and the applied limit. */
    pagination: PaginationResponse | undefined;
}
export declare const CreateGroupRequest: MessageFns<CreateGroupRequest>;
export declare const CreateGroupResponse: MessageFns<CreateGroupResponse>;
export declare const ListGroupsRequest: MessageFns<ListGroupsRequest>;
export declare const ListGroupsResponse: MessageFns<ListGroupsResponse>;
export declare const GetGroupRequest: MessageFns<GetGroupRequest>;
export declare const GetGroupResponse: MessageFns<GetGroupResponse>;
export declare const UpdateGroupRequest: MessageFns<UpdateGroupRequest>;
export declare const UpdateGroupResponse: MessageFns<UpdateGroupResponse>;
export declare const DeleteGroupRequest: MessageFns<DeleteGroupRequest>;
export declare const DeleteGroupResponse: MessageFns<DeleteGroupResponse>;
export declare const AddUsersToGroupRequest: MessageFns<AddUsersToGroupRequest>;
export declare const AddUsersToGroupResponse: MessageFns<AddUsersToGroupResponse>;
export declare const RemoveUsersFromGroupRequest: MessageFns<RemoveUsersFromGroupRequest>;
export declare const RemoveUsersFromGroupResponse: MessageFns<RemoveUsersFromGroupResponse>;
export declare const ListGroupUsersRequest: MessageFns<ListGroupUsersRequest>;
export declare const ListGroupUsersResponse: MessageFns<ListGroupUsersResponse>;
/**
 * GroupService is used to manage user groups.
 * This service provides methods to create, retrieve, update, and delete user groups in an organization.
 */
export type GroupServiceDefinition = typeof GroupServiceDefinition;
export declare const GroupServiceDefinition: {
    readonly name: "GroupService";
    readonly fullName: "zitadel.group.v2.GroupService";
    readonly methods: {
        /**
         * Create Group
         *
         * CreateGroup creates a new user group in an organization.
         *
         * Required permissions:
         *   - group.create
         */
        readonly createGroup: {
            readonly name: "CreateGroup";
            readonly requestType: MessageFns<CreateGroupRequest>;
            readonly requestStream: false;
            readonly responseType: MessageFns<CreateGroupResponse>;
            readonly responseStream: false;
            readonly options: {
                readonly _unknownFields: {
                    readonly 8338: readonly [Buffer];
                    readonly 400010: readonly [Buffer];
                };
            };
        };
        /**
         * Get Group
         *
         * Retrieves a group based on its ID.
         *
         * Required permission:
         * - group.read
         */
        readonly getGroup: {
            readonly name: "GetGroup";
            readonly requestType: MessageFns<GetGroupRequest>;
            readonly requestStream: false;
            readonly responseType: MessageFns<GetGroupResponse>;
            readonly responseStream: false;
            readonly options: {
                readonly _unknownFields: {
                    readonly 8338: readonly [Buffer];
                    readonly 400010: readonly [Buffer];
                };
            };
        };
        /**
         * List Groups
         *
         * ListGroups returns all groups matching the request and necessary permissions from an organization.
         *
         * Required permissions:
         *   - group.read
         */
        readonly listGroups: {
            readonly name: "ListGroups";
            readonly requestType: MessageFns<ListGroupsRequest>;
            readonly requestStream: false;
            readonly responseType: MessageFns<ListGroupsResponse>;
            readonly responseStream: false;
            readonly options: {
                readonly _unknownFields: {
                    readonly 8338: readonly [Buffer];
                    readonly 400010: readonly [Buffer];
                };
            };
        };
        /**
         * Update Group
         *
         * UpdateGroup updates the user group.
         *
         * In case there aren't any changes, the request will return a successful response as
         * the desired state is already achieved.
         * You can check the change date in the response to verify if the group was updated by the request.
         *
         * Required permissions:
         *   - group.write
         */
        readonly updateGroup: {
            readonly name: "UpdateGroup";
            readonly requestType: MessageFns<UpdateGroupRequest>;
            readonly requestStream: false;
            readonly responseType: MessageFns<UpdateGroupResponse>;
            readonly responseStream: false;
            readonly options: {
                readonly _unknownFields: {
                    readonly 8338: readonly [Buffer];
                    readonly 400010: readonly [Buffer];
                };
            };
        };
        /**
         * Delete Group
         *
         * DeleteGroup deletes the group.
         *
         * In case the group is not found, the request will return a successful response as
         * the desired state is already achieved.
         * You can check the deletion date in the response to verify if the group was deleted by the request.
         *
         * Required permissions:
         *   - group.delete
         */
        readonly deleteGroup: {
            readonly name: "DeleteGroup";
            readonly requestType: MessageFns<DeleteGroupRequest>;
            readonly requestStream: false;
            readonly responseType: MessageFns<DeleteGroupResponse>;
            readonly responseStream: false;
            readonly options: {
                readonly _unknownFields: {
                    readonly 8338: readonly [Buffer];
                    readonly 400010: readonly [Buffer];
                };
            };
        };
        /**
         * Add Users
         *
         * Adds one or more users to a group.
         * The users should be in the same organization as the group.
         * The request will not fail if some of the users could not be added to the group,
         * and a list of failed user IDs is available in the response.
         *
         * Required permissions:
         *   - group.user.write
         */
        readonly addUsersToGroup: {
            readonly name: "AddUsersToGroup";
            readonly requestType: MessageFns<AddUsersToGroupRequest>;
            readonly requestStream: false;
            readonly responseType: MessageFns<AddUsersToGroupResponse>;
            readonly responseStream: false;
            readonly options: {
                readonly _unknownFields: {
                    readonly 400010: readonly [Buffer];
                };
            };
        };
        /**
         * Remove Users
         *
         * Removes one or more users from a group.
         * If some of the users are not in the group, the request will still return a successful response as
         * the desired state is already achieved.
         *
         * Required permissions:
         *   - group.user.delete
         */
        readonly removeUsersFromGroup: {
            readonly name: "RemoveUsersFromGroup";
            readonly requestType: MessageFns<RemoveUsersFromGroupRequest>;
            readonly requestStream: false;
            readonly responseType: MessageFns<RemoveUsersFromGroupResponse>;
            readonly responseStream: false;
            readonly options: {
                readonly _unknownFields: {
                    readonly 400010: readonly [Buffer];
                };
            };
        };
        /**
         * List Group Users
         *
         * Allows searching for groups based on user IDs, or retrieving users based on group IDs
         *
         * Required permissions:
         *   - group.user.read
         */
        readonly listGroupUsers: {
            readonly name: "ListGroupUsers";
            readonly requestType: MessageFns<ListGroupUsersRequest>;
            readonly requestStream: false;
            readonly responseType: MessageFns<ListGroupUsersResponse>;
            readonly responseStream: false;
            readonly options: {
                readonly _unknownFields: {
                    readonly 400010: readonly [Buffer];
                };
            };
        };
    };
};
export interface GroupServiceImplementation<CallContextExt = {}> {
    /**
     * Create Group
     *
     * CreateGroup creates a new user group in an organization.
     *
     * Required permissions:
     *   - group.create
     */
    createGroup(request: CreateGroupRequest, context: CallContext & CallContextExt): Promise<DeepPartial<CreateGroupResponse>>;
    /**
     * Get Group
     *
     * Retrieves a group based on its ID.
     *
     * Required permission:
     * - group.read
     */
    getGroup(request: GetGroupRequest, context: CallContext & CallContextExt): Promise<DeepPartial<GetGroupResponse>>;
    /**
     * List Groups
     *
     * ListGroups returns all groups matching the request and necessary permissions from an organization.
     *
     * Required permissions:
     *   - group.read
     */
    listGroups(request: ListGroupsRequest, context: CallContext & CallContextExt): Promise<DeepPartial<ListGroupsResponse>>;
    /**
     * Update Group
     *
     * UpdateGroup updates the user group.
     *
     * In case there aren't any changes, the request will return a successful response as
     * the desired state is already achieved.
     * You can check the change date in the response to verify if the group was updated by the request.
     *
     * Required permissions:
     *   - group.write
     */
    updateGroup(request: UpdateGroupRequest, context: CallContext & CallContextExt): Promise<DeepPartial<UpdateGroupResponse>>;
    /**
     * Delete Group
     *
     * DeleteGroup deletes the group.
     *
     * In case the group is not found, the request will return a successful response as
     * the desired state is already achieved.
     * You can check the deletion date in the response to verify if the group was deleted by the request.
     *
     * Required permissions:
     *   - group.delete
     */
    deleteGroup(request: DeleteGroupRequest, context: CallContext & CallContextExt): Promise<DeepPartial<DeleteGroupResponse>>;
    /**
     * Add Users
     *
     * Adds one or more users to a group.
     * The users should be in the same organization as the group.
     * The request will not fail if some of the users could not be added to the group,
     * and a list of failed user IDs is available in the response.
     *
     * Required permissions:
     *   - group.user.write
     */
    addUsersToGroup(request: AddUsersToGroupRequest, context: CallContext & CallContextExt): Promise<DeepPartial<AddUsersToGroupResponse>>;
    /**
     * Remove Users
     *
     * Removes one or more users from a group.
     * If some of the users are not in the group, the request will still return a successful response as
     * the desired state is already achieved.
     *
     * Required permissions:
     *   - group.user.delete
     */
    removeUsersFromGroup(request: RemoveUsersFromGroupRequest, context: CallContext & CallContextExt): Promise<DeepPartial<RemoveUsersFromGroupResponse>>;
    /**
     * List Group Users
     *
     * Allows searching for groups based on user IDs, or retrieving users based on group IDs
     *
     * Required permissions:
     *   - group.user.read
     */
    listGroupUsers(request: ListGroupUsersRequest, context: CallContext & CallContextExt): Promise<DeepPartial<ListGroupUsersResponse>>;
}
export interface GroupServiceClient<CallOptionsExt = {}> {
    /**
     * Create Group
     *
     * CreateGroup creates a new user group in an organization.
     *
     * Required permissions:
     *   - group.create
     */
    createGroup(request: DeepPartial<CreateGroupRequest>, options?: CallOptions & CallOptionsExt): Promise<CreateGroupResponse>;
    /**
     * Get Group
     *
     * Retrieves a group based on its ID.
     *
     * Required permission:
     * - group.read
     */
    getGroup(request: DeepPartial<GetGroupRequest>, options?: CallOptions & CallOptionsExt): Promise<GetGroupResponse>;
    /**
     * List Groups
     *
     * ListGroups returns all groups matching the request and necessary permissions from an organization.
     *
     * Required permissions:
     *   - group.read
     */
    listGroups(request: DeepPartial<ListGroupsRequest>, options?: CallOptions & CallOptionsExt): Promise<ListGroupsResponse>;
    /**
     * Update Group
     *
     * UpdateGroup updates the user group.
     *
     * In case there aren't any changes, the request will return a successful response as
     * the desired state is already achieved.
     * You can check the change date in the response to verify if the group was updated by the request.
     *
     * Required permissions:
     *   - group.write
     */
    updateGroup(request: DeepPartial<UpdateGroupRequest>, options?: CallOptions & CallOptionsExt): Promise<UpdateGroupResponse>;
    /**
     * Delete Group
     *
     * DeleteGroup deletes the group.
     *
     * In case the group is not found, the request will return a successful response as
     * the desired state is already achieved.
     * You can check the deletion date in the response to verify if the group was deleted by the request.
     *
     * Required permissions:
     *   - group.delete
     */
    deleteGroup(request: DeepPartial<DeleteGroupRequest>, options?: CallOptions & CallOptionsExt): Promise<DeleteGroupResponse>;
    /**
     * Add Users
     *
     * Adds one or more users to a group.
     * The users should be in the same organization as the group.
     * The request will not fail if some of the users could not be added to the group,
     * and a list of failed user IDs is available in the response.
     *
     * Required permissions:
     *   - group.user.write
     */
    addUsersToGroup(request: DeepPartial<AddUsersToGroupRequest>, options?: CallOptions & CallOptionsExt): Promise<AddUsersToGroupResponse>;
    /**
     * Remove Users
     *
     * Removes one or more users from a group.
     * If some of the users are not in the group, the request will still return a successful response as
     * the desired state is already achieved.
     *
     * Required permissions:
     *   - group.user.delete
     */
    removeUsersFromGroup(request: DeepPartial<RemoveUsersFromGroupRequest>, options?: CallOptions & CallOptionsExt): Promise<RemoveUsersFromGroupResponse>;
    /**
     * List Group Users
     *
     * Allows searching for groups based on user IDs, or retrieving users based on group IDs
     *
     * Required permissions:
     *   - group.user.read
     */
    listGroupUsers(request: DeepPartial<ListGroupUsersRequest>, options?: CallOptions & CallOptionsExt): Promise<ListGroupUsersResponse>;
}
type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;
export type DeepPartial<T> = T extends Builtin ? T : T extends Long ? string | number | Long : T extends globalThis.Array<infer U> ? globalThis.Array<DeepPartial<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>> : T extends {} ? {
    [K in keyof T]?: DeepPartial<T[K]>;
} : Partial<T>;
export interface MessageFns<T> {
    encode(message: T, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): T;
    fromJSON(object: any): T;
    toJSON(message: T): unknown;
    create(base?: DeepPartial<T>): T;
    fromPartial(object: DeepPartial<T>): T;
}
export {};