import { ColumnItemAsResponse } from "../definitions/ColumnItemAsResponse";
import { HeadersOption, ConnectionOption } from "@avst-api/commons";
import { AssistedErrorStrategyOption } from "../handled-api/common";
import { ErrorStrategyOption } from "../handled-api/common";
import { UserAsResponse } from "../definitions/UserAsResponse";
import { NewUserDetails } from "../definitions/NewUserDetails";
import { FoundUsersAsResponse } from "../definitions/FoundUsersAsResponse";
import { PageBeanUserAsResponse } from "../definitions/PageBeanUserAsResponse";
import { PageBeanUserKeyAsResponse } from "../definitions/PageBeanUserKeyAsResponse";
import { UserMigrationBeanAsResponse } from "../definitions/UserMigrationBeanAsResponse";
import { UnrestrictedUserEmailAsResponse } from "../definitions/UnrestrictedUserEmailAsResponse";
import { GroupNameAsResponse } from "../definitions/GroupNameAsResponse";
import { PropertyKeysAsResponse } from "../definitions/PropertyKeysAsResponse";
import { EntityPropertyAsResponse } from "../definitions/EntityPropertyAsResponse";
export declare namespace User {
    namespace GetDefaultColumns {
        interface Options extends Options.Base, HeadersOption, AssistedErrorStrategyOption {
        }
        namespace Response {
            type OK = Array<ColumnItemAsResponse>;
            type Error = undefined;
        }
        namespace Options {
            interface Base {
                /**
                 * The account ID of the user, which uniquely identifies the user across all Atlassian products. For example, *5b10ac8d82e05b22cc7d4ef5*.
                 */
                accountId?: string;
            }
            interface RawApi extends Base, ConnectionOption, HeadersOption {
            }
            interface HandledApi extends RawApi, ErrorStrategyOption {
            }
        }
    }
    namespace SetDefaultColumns {
        interface Options extends Options.Base, HeadersOption, AssistedErrorStrategyOption {
        }
        type Body = {
            /**
             * The ID of a column
             */
            columns: Array<string>;
        };
        namespace Response {
            type OK = any;
            type Error = undefined;
        }
        namespace Options {
            interface Base {
                /**
                 * The account ID of the user, which uniquely identifies the user across all Atlassian products. For example, *5b10ac8d82e05b22cc7d4ef5*.
                 */
                accountId?: string;
                body: User.SetDefaultColumns.Body;
            }
            interface RawApi extends Base, ConnectionOption, HeadersOption {
            }
            interface HandledApi extends RawApi, ErrorStrategyOption {
            }
        }
    }
    namespace ResetDefaultColumns {
        interface Options extends Options.Base, HeadersOption, AssistedErrorStrategyOption {
        }
        namespace Response {
            type OK = undefined;
            type Error = undefined;
        }
        namespace Options {
            interface Base {
                /**
                 * The account ID of the user, which uniquely identifies the user across all Atlassian products. For example, *5b10ac8d82e05b22cc7d4ef5*.
                 */
                accountId?: string;
            }
            interface RawApi extends Base, ConnectionOption, HeadersOption {
            }
            interface HandledApi extends RawApi, ErrorStrategyOption {
            }
        }
    }
    namespace GetUser {
        interface Options extends Options.Base, HeadersOption, AssistedErrorStrategyOption {
        }
        namespace Response {
            type OK = UserAsResponse;
            type Error = undefined;
        }
        namespace Options {
            interface Base {
                /**
                 * The account ID of the user, which uniquely identifies the user across all Atlassian products. For example, *5b10ac8d82e05b22cc7d4ef5*. Required.
                 */
                accountId?: string;
                /**
                 * This parameter is no longer available. See the [deprecation notice](https://developer.atlassian.com/cloud/jira/platform/deprecation-notice-user-privacy-api-migration-guide) for details.
                 */
                username?: string;
                /**
                 * This parameter is no longer available. See the [deprecation notice](https://developer.atlassian.com/cloud/jira/platform/deprecation-notice-user-privacy-api-migration-guide) for details.
                 */
                key?: string;
                /**
        * Use [expand](#expansion) to include additional information about users in the response. This parameter accepts a comma-separated list. Expand options include:
        
         *  `groups` includes all groups and nested groups to which the user belongs.
         *  `applicationRoles` includes details of all the applications to which the user has access.
        */
                expand?: string;
            }
            interface RawApi extends Base, ConnectionOption, HeadersOption {
            }
            interface HandledApi extends RawApi, ErrorStrategyOption {
            }
        }
    }
    namespace CreateUser {
        interface Options extends Options.Base, HeadersOption, AssistedErrorStrategyOption {
        }
        type Body = NewUserDetails;
        namespace Response {
            type OK = UserAsResponse;
            type Error = undefined;
        }
        namespace Options {
            interface Base {
                body: User.CreateUser.Body;
            }
            interface RawApi extends Base, ConnectionOption, HeadersOption {
            }
            interface HandledApi extends RawApi, ErrorStrategyOption {
            }
        }
    }
    namespace DeleteUser {
        interface Options extends Options.Base, HeadersOption, AssistedErrorStrategyOption {
        }
        namespace Response {
            type OK = undefined;
            type Error = undefined;
        }
        namespace Options {
            interface Base {
                /**
                 * The account ID of the user, which uniquely identifies the user across all Atlassian products. For example, *5b10ac8d82e05b22cc7d4ef5*.
                 */
                accountId: string;
                /**
                 * This parameter is no longer available. See the [deprecation notice](https://developer.atlassian.com/cloud/jira/platform/deprecation-notice-user-privacy-api-migration-guide/) for details.
                 */
                username?: string;
                /**
                 * This parameter is no longer available. See the [deprecation notice](https://developer.atlassian.com/cloud/jira/platform/deprecation-notice-user-privacy-api-migration-guide/) for details.
                 */
                key?: string;
            }
            interface RawApi extends Base, ConnectionOption, HeadersOption {
            }
            interface HandledApi extends RawApi, ErrorStrategyOption {
            }
        }
    }
    namespace Search {
        namespace FindUsersAssignableToProjects {
            interface Options extends Options.Base, HeadersOption, AssistedErrorStrategyOption {
            }
            namespace Response {
                type OK = Array<UserAsResponse>;
                type Error = undefined;
            }
            namespace Options {
                interface Base {
                    /**
                     * A query string that is matched against user attributes, such as `displayName` and `emailAddress`, to find relevant users. The string can match the prefix of the attribute's value. For example, *query=john* matches a user with a `displayName` of *John Smith* and a user with an `emailAddress` of *johnson@example.com*. Required, unless `accountId` is specified.
                     */
                    query?: string;
                    /**
                     * This parameter is no longer available. See the [deprecation notice](https://developer.atlassian.com/cloud/jira/platform/deprecation-notice-user-privacy-api-migration-guide/) for details.
                     */
                    username?: string;
                    /**
                     * A query string that is matched exactly against user `accountId`. Required, unless `query` is specified.
                     */
                    accountId?: string;
                    /**
                     * A list of project keys (case sensitive). This parameter accepts a comma-separated list.
                     */
                    projectKeys: string;
                    /**
                     * The index of the first item to return in a page of results (page offset).
                     */
                    startAt?: number;
                    /**
                     * The maximum number of items to return per page.
                     */
                    maxResults?: number;
                }
                interface RawApi extends Base, ConnectionOption, HeadersOption {
                }
                interface HandledApi extends RawApi, ErrorStrategyOption {
                }
            }
        }
        namespace FindUsersAssignableToIssues {
            interface Options extends Options.Base, HeadersOption, AssistedErrorStrategyOption {
            }
            namespace Response {
                type OK = Array<UserAsResponse>;
                type Error = undefined;
            }
            namespace Options {
                interface Base {
                    /**
                     * A query string that is matched against user attributes, such as `displayName`, and `emailAddress`, to find relevant users. The string can match the prefix of the attribute's value. For example, *query=john* matches a user with a `displayName` of *John Smith* and a user with an `emailAddress` of *johnson@example.com*. Required, unless `username` or `accountId` is specified.
                     */
                    query?: string;
                    /**
                     * The sessionId of this request. SessionId is the same until the assignee is set.
                     */
                    sessionId?: string;
                    /**
                     * This parameter is no longer available. See the [deprecation notice](https://developer.atlassian.com/cloud/jira/platform/deprecation-notice-user-privacy-api-migration-guide/) for details.
                     */
                    username?: string;
                    /**
                     * A query string that is matched exactly against user `accountId`. Required, unless `query` is specified.
                     */
                    accountId?: string;
                    /**
                     * The project ID or project key (case sensitive). Required, unless `issueKey` is specified.
                     */
                    project?: string;
                    /**
                     * The key of the issue. Required, unless `project` is specified.
                     */
                    issueKey?: string;
                    /**
                     * The index of the first item to return in a page of results (page offset).
                     */
                    startAt?: number;
                    /**
                     * The maximum number of items to return. This operation may return less than the maximum number of items even if more are available. The operation fetches users up to the maximum and then, from the fetched users, returns only the users that can be assigned to the issue.
                     */
                    maxResults?: number;
                    /**
                     * The ID of the transition.
                     */
                    actionDescriptorId?: number;
                    recommend?: boolean;
                }
                interface RawApi extends Base, ConnectionOption, HeadersOption {
                }
                interface HandledApi extends RawApi, ErrorStrategyOption {
                }
            }
        }
        namespace FindUsersWithPermissions {
            interface Options extends Options.Base, HeadersOption, AssistedErrorStrategyOption {
            }
            namespace Response {
                type OK = Array<UserAsResponse>;
                type Error = undefined;
            }
            namespace Options {
                interface Base {
                    /**
                     * A query string that is matched against user attributes, such as `displayName` and `emailAddress`, to find relevant users. The string can match the prefix of the attribute's value. For example, *query=john* matches a user with a `displayName` of *John Smith* and a user with an `emailAddress` of *johnson@example.com*. Required, unless `accountId` is specified.
                     */
                    query?: string;
                    /**
                     * This parameter is no longer available. See the [deprecation notice](https://developer.atlassian.com/cloud/jira/platform/deprecation-notice-user-privacy-api-migration-guide/) for details.
                     */
                    username?: string;
                    /**
                     * A query string that is matched exactly against user `accountId`. Required, unless `query` is specified.
                     */
                    accountId?: string;
                    /**
          * A comma separated list of permissions. Permissions can be specified as any:
          
           *  permission returned by [Get all permissions](#api-rest-api-3-permissions-get).
           *  custom project permission added by Connect apps.
           *  (deprecated) one of the following:
              
               *  ASSIGNABLE\_USER
               *  ASSIGN\_ISSUE
               *  ATTACHMENT\_DELETE\_ALL
               *  ATTACHMENT\_DELETE\_OWN
               *  BROWSE
               *  CLOSE\_ISSUE
               *  COMMENT\_DELETE\_ALL
               *  COMMENT\_DELETE\_OWN
               *  COMMENT\_EDIT\_ALL
               *  COMMENT\_EDIT\_OWN
               *  COMMENT\_ISSUE
               *  CREATE\_ATTACHMENT
               *  CREATE\_ISSUE
               *  DELETE\_ISSUE
               *  EDIT\_ISSUE
               *  LINK\_ISSUE
               *  MANAGE\_WATCHER\_LIST
               *  MODIFY\_REPORTER
               *  MOVE\_ISSUE
               *  PROJECT\_ADMIN
               *  RESOLVE\_ISSUE
               *  SCHEDULE\_ISSUE
               *  SET\_ISSUE\_SECURITY
               *  TRANSITION\_ISSUE
               *  VIEW\_VERSION\_CONTROL
               *  VIEW\_VOTERS\_AND\_WATCHERS
               *  VIEW\_WORKFLOW\_READONLY
               *  WORKLOG\_DELETE\_ALL
               *  WORKLOG\_DELETE\_OWN
               *  WORKLOG\_EDIT\_ALL
               *  WORKLOG\_EDIT\_OWN
               *  WORK\_ISSUE
          */
                    permissions: string;
                    /**
                     * The issue key for the issue.
                     */
                    issueKey?: string;
                    /**
                     * The project key for the project (case sensitive).
                     */
                    projectKey?: string;
                    /**
                     * The index of the first item to return in a page of results (page offset).
                     */
                    startAt?: number;
                    /**
                     * The maximum number of items to return per page.
                     */
                    maxResults?: number;
                }
                interface RawApi extends Base, ConnectionOption, HeadersOption {
                }
                interface HandledApi extends RawApi, ErrorStrategyOption {
                }
            }
        }
        namespace FindUsersForPicker {
            interface Options extends Options.Base, HeadersOption, AssistedErrorStrategyOption {
            }
            namespace Response {
                type OK = FoundUsersAsResponse;
                type Error = undefined;
            }
            namespace Options {
                interface Base {
                    /**
                     * A query string that is matched against user attributes, such as `displayName`, and `emailAddress`, to find relevant users. The string can match the prefix of the attribute's value. For example, *query=john* matches a user with a `displayName` of *John Smith* and a user with an `emailAddress` of *johnson@example.com*.
                     */
                    query: string;
                    /**
                     * The maximum number of items to return. The total number of matched users is returned in `total`.
                     */
                    maxResults?: number;
                    /**
                     * Include the URI to the user's avatar.
                     */
                    showAvatar?: boolean;
                    /**
                     * A list of account IDs to exclude from the search results. This parameter accepts a comma-separated list. Multiple account IDs can also be provided using an ampersand-separated list. For example, `excludeAccountIds=5b10a2844c20165700ede21g,5b10a0effa615349cb016cd8&excludeAccountIds=5b10ac8d82e05b22cc7d4ef5`. Cannot be provided with `exclude`.
                     */
                    excludeAccountIds?: Array<string>;
                    avatarSize?: string;
                    excludeConnectUsers?: boolean;
                }
                interface RawApi extends Base, ConnectionOption, HeadersOption {
                }
                interface HandledApi extends RawApi, ErrorStrategyOption {
                }
            }
        }
        namespace FindUsers {
            interface Options extends Options.Base, HeadersOption, AssistedErrorStrategyOption {
            }
            namespace Response {
                type OK = Array<UserAsResponse>;
                type Error = undefined;
            }
            namespace Options {
                interface Base {
                    /**
                     * A query string that is matched against user attributes ( `displayName`, and `emailAddress`) to find relevant users. The string can match the prefix of the attribute's value. For example, *query=john* matches a user with a `displayName` of *John Smith* and a user with an `emailAddress` of *johnson@example.com*. Required, unless `accountId` or `property` is specified.
                     */
                    query?: string;
                    username?: string;
                    /**
                     * A query string that is matched exactly against a user `accountId`. Required, unless `query` or `property` is specified.
                     */
                    accountId?: string;
                    /**
                     * The index of the first item to return in a page of results (page offset).
                     */
                    startAt?: number;
                    /**
                     * The maximum number of items to return per page.
                     */
                    maxResults?: number;
                    /**
                     * A query string used to search properties. Property keys are specified by path, so property keys containing dot (.) or equals (=) characters cannot be used. The query string cannot be specified using a JSON object. Example: To search for the value of `nested` from `{"something":{"nested":1,"other":2}}` use `thepropertykey.something.nested=1`. Required, unless `accountId` or `query` is specified.
                     */
                    property?: string;
                }
                interface RawApi extends Base, ConnectionOption, HeadersOption {
                }
                interface HandledApi extends RawApi, ErrorStrategyOption {
                }
            }
        }
        namespace FindUsersByQuery {
            interface Options extends Options.Base, HeadersOption, AssistedErrorStrategyOption {
            }
            namespace Response {
                type OK = PageBeanUserAsResponse;
                type Error = undefined;
            }
            namespace Options {
                interface Base {
                    /**
                     * The search query.
                     */
                    query: string;
                    /**
                     * The index of the first item to return in a page of results (page offset).
                     */
                    startAt?: number;
                    /**
                     * The maximum number of items to return per page.
                     */
                    maxResults?: number;
                }
                interface RawApi extends Base, ConnectionOption, HeadersOption {
                }
                interface HandledApi extends RawApi, ErrorStrategyOption {
                }
            }
        }
        namespace FindUserKeysByQuery {
            interface Options extends Options.Base, HeadersOption, AssistedErrorStrategyOption {
            }
            namespace Response {
                type OK = PageBeanUserKeyAsResponse;
                type Error = undefined;
            }
            namespace Options {
                interface Base {
                    /**
                     * The search query.
                     */
                    query: string;
                    /**
                     * The index of the first item to return in a page of results (page offset).
                     */
                    startAt?: number;
                    /**
                     * The maximum number of items to return per page.
                     */
                    maxResults?: number;
                }
                interface RawApi extends Base, ConnectionOption, HeadersOption {
                }
                interface HandledApi extends RawApi, ErrorStrategyOption {
                }
            }
        }
        namespace FindUsersWithBrowsePermission {
            interface Options extends Options.Base, HeadersOption, AssistedErrorStrategyOption {
            }
            namespace Response {
                type OK = Array<UserAsResponse>;
                type Error = undefined;
            }
            namespace Options {
                interface Base {
                    /**
                     * A query string that is matched against user attributes, such as `displayName` and `emailAddress`, to find relevant users. The string can match the prefix of the attribute's value. For example, *query=john* matches a user with a `displayName` of *John Smith* and a user with an `emailAddress` of *johnson@example.com*. Required, unless `accountId` is specified.
                     */
                    query?: string;
                    /**
                     * This parameter is no longer available. See the [deprecation notice](https://developer.atlassian.com/cloud/jira/platform/deprecation-notice-user-privacy-api-migration-guide/) for details.
                     */
                    username?: string;
                    /**
                     * A query string that is matched exactly against user `accountId`. Required, unless `query` is specified.
                     */
                    accountId?: string;
                    /**
                     * The issue key for the issue. Required, unless `projectKey` is specified.
                     */
                    issueKey?: string;
                    /**
                     * The project key for the project (case sensitive). Required, unless `issueKey` is specified.
                     */
                    projectKey?: string;
                    /**
                     * The index of the first item to return in a page of results (page offset).
                     */
                    startAt?: number;
                    /**
                     * The maximum number of items to return per page.
                     */
                    maxResults?: number;
                }
                interface RawApi extends Base, ConnectionOption, HeadersOption {
                }
                interface HandledApi extends RawApi, ErrorStrategyOption {
                }
            }
        }
    }
    namespace GetAccountIdsForUsers {
        interface Options extends Options.Base, HeadersOption, AssistedErrorStrategyOption {
        }
        namespace Response {
            type OK = Array<UserMigrationBeanAsResponse>;
            type Error = undefined;
        }
        namespace Options {
            interface Base {
                /**
                 * The index of the first item to return in a page of results (page offset).
                 */
                startAt?: number;
                /**
                 * The maximum number of items to return per page.
                 */
                maxResults?: number;
                /**
                 * Username of a user. To specify multiple users, pass multiple copies of this parameter. For example, `username=fred&username=barney`. Required if `key` isn't provided. Cannot be provided if `key` is present.
                 */
                username?: Array<string>;
                /**
                 * Key of a user. To specify multiple users, pass multiple copies of this parameter. For example, `key=fred&key=barney`. Required if `username` isn't provided. Cannot be provided if `username` is present.
                 */
                key?: Array<string>;
            }
            interface RawApi extends Base, ConnectionOption, HeadersOption {
            }
            interface HandledApi extends RawApi, ErrorStrategyOption {
            }
        }
    }
    namespace GetEmail {
        interface Options extends Options.Base, HeadersOption, AssistedErrorStrategyOption {
        }
        namespace Response {
            type OK = UnrestrictedUserEmailAsResponse;
            type Error = undefined;
        }
        namespace Options {
            interface Base {
                /**
                 * The account ID of the user, which uniquely identifies the user across all Atlassian products. For example, `5b10ac8d82e05b22cc7d4ef5`.
                 */
                accountId: string;
            }
            interface RawApi extends Base, ConnectionOption, HeadersOption {
            }
            interface HandledApi extends RawApi, ErrorStrategyOption {
            }
        }
    }
    namespace GetGroups {
        interface Options extends Options.Base, HeadersOption, AssistedErrorStrategyOption {
        }
        namespace Response {
            type OK = Array<GroupNameAsResponse>;
            type Error = undefined;
        }
        namespace Options {
            interface Base {
                /**
                 * The account ID of the user, which uniquely identifies the user across all Atlassian products. For example, *5b10ac8d82e05b22cc7d4ef5*.
                 */
                accountId: string;
                /**
                 * This parameter is no longer available. See the [deprecation notice](https://developer.atlassian.com/cloud/jira/platform/deprecation-notice-user-privacy-api-migration-guide/) for details.
                 */
                username?: string;
                /**
                 * This parameter is no longer available. See the [deprecation notice](https://developer.atlassian.com/cloud/jira/platform/deprecation-notice-user-privacy-api-migration-guide/) for details.
                 */
                key?: string;
            }
            interface RawApi extends Base, ConnectionOption, HeadersOption {
            }
            interface HandledApi extends RawApi, ErrorStrategyOption {
            }
        }
    }
    namespace GetUsers {
        interface Options extends Options.Base, HeadersOption, AssistedErrorStrategyOption {
        }
        namespace Response {
            type OK = Array<UserAsResponse>;
            type Error = undefined;
        }
        namespace Options {
            interface Base {
                /**
                 * The index of the first item to return.
                 */
                startAt?: number;
                /**
                 * The maximum number of items to return.
                 */
                maxResults?: number;
            }
            interface RawApi extends Base, ConnectionOption, HeadersOption {
            }
            interface HandledApi extends RawApi, ErrorStrategyOption {
            }
        }
    }
    namespace Property {
        namespace GetPropertyKeys {
            interface Options extends Options.Base, HeadersOption, AssistedErrorStrategyOption {
            }
            namespace Response {
                type OK = PropertyKeysAsResponse;
                type Error = undefined;
            }
            namespace Options {
                interface Base {
                    /**
                     * The account ID of the user, which uniquely identifies the user across all Atlassian products. For example, *5b10ac8d82e05b22cc7d4ef5*.
                     */
                    accountId: string;
                }
                interface RawApi extends Base, ConnectionOption, HeadersOption {
                }
                interface HandledApi extends RawApi, ErrorStrategyOption {
                }
            }
        }
        namespace GetProperty {
            interface Options extends Options.Base, HeadersOption, AssistedErrorStrategyOption {
            }
            namespace Response {
                type OK = EntityPropertyAsResponse;
                type Error = undefined;
            }
            namespace Options {
                interface Base {
                    /**
                     * The key of the user's property.
                     */
                    propertyKey: string;
                    /**
                     * The account ID of the user, which uniquely identifies the user across all Atlassian products. For example, *5b10ac8d82e05b22cc7d4ef5*.
                     */
                    accountId: string;
                }
                interface RawApi extends Base, ConnectionOption, HeadersOption {
                }
                interface HandledApi extends RawApi, ErrorStrategyOption {
                }
            }
        }
        namespace SetProperty {
            interface Options extends Options.Base, HeadersOption, AssistedErrorStrategyOption {
            }
            type Body = any;
            namespace Response {
                type OK = any;
                type Error = undefined;
            }
            namespace Options {
                interface Base {
                    /**
                     * The key of the user's property. The maximum length is 255 characters. If no such property exists, it will be created
                     */
                    propertyKey: string;
                    /**
                     * The account ID of the user, which uniquely identifies the user across all Atlassian products. For example, *5b10ac8d82e05b22cc7d4ef5*.
                     */
                    accountId: string;
                    body: User.Property.SetProperty.Body;
                }
                interface RawApi extends Base, ConnectionOption, HeadersOption {
                }
                interface HandledApi extends RawApi, ErrorStrategyOption {
                }
            }
        }
        namespace DeleteProperty {
            interface Options extends Options.Base, HeadersOption, AssistedErrorStrategyOption {
            }
            namespace Response {
                type OK = undefined;
                type Error = undefined;
            }
            namespace Options {
                interface Base {
                    /**
                     * The key of the user's property.
                     */
                    propertyKey: string;
                    /**
                     * The account ID of the user, which uniquely identifies the user across all Atlassian products. For example, *5b10ac8d82e05b22cc7d4ef5*.
                     */
                    accountId: string;
                }
                interface RawApi extends Base, ConnectionOption, HeadersOption {
                }
                interface HandledApi extends RawApi, ErrorStrategyOption {
                }
            }
        }
    }
}
//# sourceMappingURL=user.d.ts.map