export interface User {
    /** User ID. */
    id?: string;
    /**
     * Deprecated.
     * @deprecated
     */
    roles?: string[];
    /** User's email address. */
    email?: string;
    /** User's name. */
    name?: Name;
    /** URL to user's profile image, when provided. */
    profileImage?: string | null;
    /** Date the user joined the team. */
    joinedTeamAt?: Date | null;
    /**
     * Deprecated.
     * @deprecated
     */
    policyIds?: string[];
    /** Resources the user can access. */
    assignments?: Assignment[];
}
export interface Name {
    /** User's first name. */
    firstName?: string;
    /** User's last name. */
    lastName?: string;
}
export interface Assignment {
    /** Role assigned to the user. */
    policy?: AssignedPolicy;
    /** Unique ID for this specific assignment. */
    assignmentId?: string;
    /** Identity assigned to the asset in an assignment, referred to as subject. Supported subjects include user IDs, account IDs, and app IDs. */
    subject?: Subject;
}
export interface AssignedPolicy {
    /** Role ID. */
    policyId?: string;
    /** Role title. */
    title?: string | null;
    /** Role description. */
    description?: string | null;
}
export interface Restriction extends RestrictionRestrictionsOneOf {
    /**
     * Deprecated.
     * @deprecated
     */
    resource?: ApiResource;
    /** List of conditions restricting the user's access. Currently only folder conditions are supported. */
    conditions?: Conditions;
    /** Site where the assignment restrictions apply. */
    site?: SiteRestriction;
}
/** @oneof */
export interface RestrictionRestrictionsOneOf {
    /**
     * Deprecated.
     * @deprecated
     */
    resource?: ApiResource;
    /** List of conditions restricting the user's access. Currently only folder conditions are supported. */
    conditions?: Conditions;
    /** Site where the assignment restrictions apply. */
    site?: SiteRestriction;
}
export interface ApiResource {
    /** Resource type. */
    resourceType?: ResourceType;
    /** Resource ID. */
    id?: string;
    value?: string | null;
}
export declare enum ResourceType {
    UNKNOWN_RESOURCE_TYPE = "UNKNOWN_RESOURCE_TYPE",
    SITE = "SITE"
}
export interface Conditions {
    /** List of conditions. */
    conditions?: ApiCondition[];
}
export interface ApiCondition {
    /** Condition type. */
    conditionType?: ConditionAttributeType;
    /** Condition ID. */
    id?: string;
    /** Expected value of the condition. When `conditionType` = "FOLDER", this is the folder path. */
    value?: string | null;
}
export declare enum ConditionAttributeType {
    UNKNOWN_CONDITION_TYPE = "UNKNOWN_CONDITION_TYPE",
    FOLDER = "FOLDER"
}
export interface SiteRestriction {
    /** Site ID. */
    id?: string;
    /** Site name. */
    value?: string | null;
}
export interface CompanionResource {
    /** Asset ID (referred to here as resource ID). */
    id?: string;
    /** Asset type (referred to here as resource type). as predefined in the authorization system */
    resourceType?: string;
}
export interface Subject {
    /** ID of identity assigned to the asset. */
    id?: string;
    /** Type of identity assigned to the asset. Supported subject types include user IDs, account IDs, and app IDs. */
    subjectType?: SubjectType;
    /** Context of identity assigned to the asset. For example, a `subjectType` = `USER` will have `context` = `ACCOUNT`. */
    context?: SubjectContext;
}
export declare enum SubjectType {
    UNKNOWN = "UNKNOWN",
    ACCOUNT = "ACCOUNT",
    USER = "USER",
    USER_GROUP = "USER_GROUP",
    MEMBER_GROUP = "MEMBER_GROUP",
    VISITOR_GROUP = "VISITOR_GROUP",
    EXTERNAL_APP = "EXTERNAL_APP",
    ACCOUNT_GROUP = "ACCOUNT_GROUP",
    WIX_APP = "WIX_APP"
}
export interface SubjectContext {
    id?: string;
    contextType?: SubjectContextType;
}
export declare enum SubjectContextType {
    UNKNOWN_CTX = "UNKNOWN_CTX",
    ORG_CTX = "ORG_CTX",
    ACCOUNT_CTX = "ACCOUNT_CTX"
}
export interface GetTeamRequest {
    /** @deprecated */
    usersLimit?: number | null;
    /** The locale of the request. Defaults to en */
    locale?: string | null;
    paging?: Paging;
}
export interface Paging {
    /** Number of items to load. */
    limit?: number | null;
    /** Number of items to skip in the current sort order. */
    offset?: number | null;
}
export interface GetTeamResponse {
    users?: User[];
    invites?: AccountInvite[];
    accountInfo?: AccountInfo;
    permissions?: string[];
    userId?: string;
    targetAccountId?: string;
    policies?: ApiPolicy[];
    totalUsersInAccount?: string;
    predefinedRoles?: PredefinedRoles;
}
export interface AccountInvite {
    /**
     * Invite ID.
     * @readonly
     */
    id?: string;
    /**
     * Account ID.
     * @readonly
     */
    accountId?: string;
    /** Email address where the invite was sent. */
    email?: string;
    /**
     * Deprecated. Use `policyIds`.
     * @deprecated
     */
    role?: string;
    /**
     * Deprecated. Use `inviterAccountId`.
     * @readonly
     * @deprecated
     */
    inviterId?: string;
    /**
     * Invite status.
     *
     * Supported values:
     * - **Pending:** The invite has been sent and is valid, waiting for the user's response.
     * - **Used:** The invite has been accepted.
     * - **Deleted:** The invite has been deleted or revoked.
     * - **Declined:** The user has declined the invite.
     * - **Expired:** The invite has expired without being accepted.
     */
    status?: InviteStatus;
    /** Link to accept the invite. */
    acceptLink?: string;
    /**
     * Inviting account ID.
     * @readonly
     */
    inviterAccountId?: string;
    /**
     * Account ID that accepted the invite. Populated only once the invite is accepted.
     * @readonly
     */
    acceptedByAccountId?: string | null;
    /** Date the invite was created. */
    dateCreated?: Date | null;
    /** Role IDs included in the invite. */
    policyIds?: string[];
    /** Date the invite was last updated. */
    dateUpdated?: Date | null;
    /** Assets the users are invited to join. */
    assignments?: InviteResourceAssignment[];
    /** Invite expiration date. */
    expirationDate?: Date | null;
}
/** Invite status stating whether the invite was accepted, waiting to be accepted, deleted etc.. */
export declare enum InviteStatus {
    Pending = "Pending",
    Used = "Used",
    Deleted = "Deleted",
    Declined = "Declined",
    Expired = "Expired"
}
export interface InviteResourceAssignment {
    /** Role ID. */
    policyId?: string;
    /** Resources the user will be able to access. */
    assignments?: InviteAssignment[];
}
export interface InviteAssignment {
    /** Full name of resource to be assigned. */
    fullNameResource?: FullNameResource;
}
export interface FullNameResource extends FullNameResourceResourceContextOneOf {
    /** Specific site details. */
    siteContext?: SiteResourceContext;
    /** Specific account details. */
    accountContext?: AccountResourceContext;
}
/** @oneof */
export interface FullNameResourceResourceContextOneOf {
    /** Specific site details. */
    siteContext?: SiteResourceContext;
    /** Specific account details. */
    accountContext?: AccountResourceContext;
}
/** Site resource context. It indicates that the resource is under a site (can be the site itself or some asset of a site, like a blog post) */
export interface SiteResourceContext {
    /** Site ID. */
    metasiteId?: string;
}
/** Account resource contexts. It indicates that the resource is under the account (can be the account itself or some asset of an account, like a logo or a domain) */
export interface AccountResourceContext {
    /** Account ID. */
    accountId?: string;
}
export interface OrganizationResourceContext {
}
/**
 * A custom resource. Is used to represent some asset that is not a direct resource context (site or account), but something custom.
 * For example: payment method, blog post, domain, logo.
 */
export interface Resource {
    /** The resource id. */
    id?: string | null;
    /** The resource type */
    type?: string | null;
}
export interface PolicyCondition {
    /** The type of the condition */
    condition?: ConditionType;
}
export interface ConditionType extends ConditionTypeOfOneOf {
    /** @deprecated */
    simpleCondition?: SimpleCondition;
    /** A logic combination between several conditions, with an operator between them */
    joinedConditions?: JoinedCondition;
    /** @deprecated */
    environmentCondition?: EnvironmentCondition;
    /** A single condition */
    condition?: Condition;
}
/** @oneof */
export interface ConditionTypeOfOneOf {
    /** @deprecated */
    simpleCondition?: SimpleCondition;
    /** A logic combination between several conditions, with an operator between them */
    joinedConditions?: JoinedCondition;
    /** @deprecated */
    environmentCondition?: EnvironmentCondition;
    /** A single condition */
    condition?: Condition;
}
export interface SimpleCondition {
    attrName?: string;
    value?: SimpleConditionValue;
    op?: SimpleConditionOperator;
    conditionModelId?: string;
}
export interface SimpleConditionValue extends SimpleConditionValueValueOneOf {
    attrName?: string;
    stringValue?: string;
    boolValue?: boolean;
}
/** @oneof */
export interface SimpleConditionValueValueOneOf {
    attrName?: string;
    stringValue?: string;
    boolValue?: boolean;
}
export declare enum SimpleConditionOperator {
    UNKNOWN_SIMPLE_OP = "UNKNOWN_SIMPLE_OP",
    EQUAL = "EQUAL"
}
export interface JoinedCondition {
    /** The operator that should be used when evaluating the condition */
    op?: JoinedConditionOperator;
    /** The conditions that should be evaluated, and then joined using the operator provided */
    conditions?: ConditionType[];
}
export declare enum JoinedConditionOperator {
    UNKNOWN_JOIN_OP = "UNKNOWN_JOIN_OP",
    OR = "OR",
    AND = "AND"
}
export interface EnvironmentCondition extends EnvironmentConditionConditionOneOf {
    experimentCondition?: ExperimentCondition;
}
/** @oneof */
export interface EnvironmentConditionConditionOneOf {
    experimentCondition?: ExperimentCondition;
}
export interface ExperimentCondition {
    spec?: string;
    fallbackValue?: string;
    expectedValue?: string;
}
export interface Condition {
    /** The unique identifier of the condition model. Indicates which actions the condition is working on */
    conditionModelId?: string;
    /** The operator that should be evaluated */
    operator?: ConditionOperator;
}
export interface ConditionOperator extends ConditionOperatorOperatorsOneOf {
    /** Comparison of equality - will be evaluated to true if the given parties are equal */
    equals?: EqualOperator;
    /** Regex operator - will be evaluated to true if the given value matches the provided regex */
    like?: LikeOperator;
    /** Petri experiment - will be evaluated using petri. */
    experiment?: ExperimentOperator;
    /** Operator that indicates a dependency on another subject being allowed to perform something. */
    dependOn?: DependOnOperator;
}
/** @oneof */
export interface ConditionOperatorOperatorsOneOf {
    /** Comparison of equality - will be evaluated to true if the given parties are equal */
    equals?: EqualOperator;
    /** Regex operator - will be evaluated to true if the given value matches the provided regex */
    like?: LikeOperator;
    /** Petri experiment - will be evaluated using petri. */
    experiment?: ExperimentOperator;
    /** Operator that indicates a dependency on another subject being allowed to perform something. */
    dependOn?: DependOnOperator;
}
export interface EqualOperator {
    /** The attribute which should be compared. The attribute will be first evaluated to a value, and then compared the other side (attribute/value) */
    attrName?: string;
    /** The value to compare to. If the two parties are equal - we will return true. */
    value?: ConditionValue;
}
export interface ConditionValue extends ConditionValueValueOneOf {
    /** an attribute. We'll first retrieve the value of the attribute (from the request or from pre-indexed values), and then compare to what it needs to be compared with. */
    attrName?: string;
    /** a value with a string type. Will be compared to the attribute provided, and be true only if they match the operator. */
    stringValue?: string;
    /** a value with a boolean type. Will be compared to the attribute provided, and be true only if they match the operator. */
    boolValue?: boolean;
}
/** @oneof */
export interface ConditionValueValueOneOf {
    /** an attribute. We'll first retrieve the value of the attribute (from the request or from pre-indexed values), and then compare to what it needs to be compared with. */
    attrName?: string;
    /** a value with a string type. Will be compared to the attribute provided, and be true only if they match the operator. */
    stringValue?: string;
    /** a value with a boolean type. Will be compared to the attribute provided, and be true only if they match the operator. */
    boolValue?: boolean;
}
export interface LikeOperator {
    /** The attribute which should be compared. The attribute will be first evaluated to a value, and then compared the regex values provided. */
    attrName?: string;
    /** The regex values which the attribute value should be evaluated on. If the attribute value matches at least one of the regular expressions provided - we will return true */
    values?: string[];
}
export interface ExperimentOperator {
    /** The spec to conduct the experiment on. */
    spec?: string;
    /** The value to use if the experiment could not be conducted */
    fallbackValue?: string;
    /** The expected value of the experiment conduction. If it matches the actual value - true will be returned. Otherwise - false. */
    expectedValue?: string;
}
/** Implies that the policy takes affect only if the depend on subject is permitted as well. */
export interface DependOnOperator {
    /** The subject on which the current entry depends on. If the subject is allowed to perform what the query was about - the condition will be evaluated to true. Otherwise - false */
    dependOnSubject?: Subject;
}
export interface AccountInfo {
    accountName?: string;
    accountImage?: string;
    isTeam?: boolean;
}
export interface ApiPolicy {
    id?: string;
    description?: string | null;
    name?: string | null;
    isCustom?: boolean;
    scopes?: string[];
}
export interface PredefinedRoles {
    roles?: PredefinedRole[];
}
export interface PredefinedRole {
    titleKey?: string;
    roles?: Role[];
    title?: string | null;
    areaId?: string;
}
export interface Role {
    id?: string;
    deprecatedKey?: string;
    /** @deprecated */
    titleKey?: string;
    /** @deprecated */
    descriptionKey?: string;
    deprecated?: boolean;
    restrictFromLevel?: string;
    experiments?: string[];
    appDefIds?: string[];
    title?: string | null;
    description?: string | null;
    isCustom?: boolean;
    scopes?: string[];
    availableResourceTypes?: ResourceType[];
    availableConditions?: ConditionAttributeType[];
    limitToEditorTypes?: string[];
}
export interface ChangeRoleRequest {
    /** User ID. */
    id?: string;
    /**
     * Deprecated. Use `policyIds`.
     * @deprecated
     */
    role?: string;
    /** Role IDs to be assigned. */
    policyIds?: string[];
}
export interface ChangeRoleResponse {
}
export interface RemoveMemberRequest {
    /** User ID of the team member to remove. */
    userId: string;
}
export interface RemoveMemberResponse {
}
export interface GetUsersRequest {
    /** The number of items to load */
    limit?: number | null;
    /** number of items to skip in the current sort order */
    offset?: number | null;
}
export interface GetUsersResponse {
    users?: User[];
}
export interface GetScopesRequest {
    /** The locale of the request. Defaults to en */
    locale?: string | null;
}
export interface GetScopesResponse {
    scopeAreas?: ScopeArea[];
}
export interface ScopeArea {
    title?: string;
    appDefIds?: string[];
    scopes?: PermissionScope[];
    restrictFromLevel?: ScopeLevel;
}
export interface PermissionScope {
    id?: string;
    title?: string;
    description?: string;
    level?: ScopeLevel;
    experiments?: string[];
    dependantScopes?: string[];
    restrictFromLevel?: ScopeLevel;
    deprecated?: boolean | null;
    /** The visibility of the scope for the caller */
    visibility?: Visibility;
    appDefIds?: string[];
}
export declare enum ScopeLevel {
    None = "None",
    SITE = "SITE",
    ACCOUNT = "ACCOUNT"
}
export declare enum Visibility {
    /** The scope should be visible to the caller */
    VISIBLE = "VISIBLE",
    /** The scope shouldn't be visible for the caller, because the capability that blocks it is turned on for the caller */
    BLOCKED_BY_CAPABILITY = "BLOCKED_BY_CAPABILITY"
}
export interface GetPeopleRequest {
    resource?: PeopleResource;
    peopleType?: PeopleType;
    paging?: Paging;
    /** The locale of the request. Defaults to en */
    locale?: string | null;
}
export interface PeopleResource extends PeopleResourceResourceTypeOneOf {
    site?: string;
    folder?: FolderResource;
}
/** @oneof */
export interface PeopleResourceResourceTypeOneOf {
    site?: string;
    folder?: FolderResource;
}
export interface FolderResource {
    folderId?: string;
    folderFullPath?: string;
}
export declare enum PeopleType {
    UNDEF_PEOPLE_TYPE = "UNDEF_PEOPLE_TYPE",
    CONTRIBUTOR = "CONTRIBUTOR",
    TEAM_MEMBER = "TEAM_MEMBER"
}
export interface GetPeopleResponse {
    people?: People;
}
export interface People {
    people?: Person[];
    totalPeople?: number;
}
export interface Person extends PersonPersonOneOf {
    contributor?: Contributor;
    teamMember?: TeamMember;
}
/** @oneof */
export interface PersonPersonOneOf {
    contributor?: Contributor;
    teamMember?: TeamMember;
}
export interface Contributor {
    /** Contributor's metadata. */
    metaData?: PersonMetaData;
    /** Whether the contributor account is a team account. */
    isTeam?: boolean | null;
    /** Date that the contributor joined the site. */
    joinedAt?: Date | null;
    /** Email address that received the invite. */
    invitedEmail?: string | null;
    /** Whether the contributor account is a client account. */
    isClient?: boolean | null;
    /**
     * Contributor's user ID.
     * @readonly
     */
    id?: string;
}
export interface PersonMetaData {
    /** Contributor's account ID. */
    id?: string;
    /** Contributor's full name. */
    fullName?: string | null;
    /** URL for contributor's profile image. */
    imageUrl?: string | null;
    /** Contributor's email address. */
    email?: string | null;
    /** Contributor's access to assets and their assigned role (`policy`) for that asset. */
    assignments?: Assignment[];
}
export interface TeamMember {
    metaData?: PersonMetaData;
}
export interface GetTeamV2Response {
    users?: User[];
    totalUsersInAccount?: string;
}
export interface GetTeamInvitesRequest {
    /** The locale of the request. Defaults to en */
    locale?: string | null;
}
export interface GetTeamInvitesResponse {
    invites?: Invite[];
}
export interface Invite {
    /** @readonly */
    id?: string;
    /** @readonly */
    accountId?: string;
    email?: string;
    status?: InviteStatus;
    acceptLink?: string;
    dateCreated?: Date | null;
    dateUpdated?: Date | null;
    assignments?: ApiInviteAssignment[];
    /** Invite expiration date */
    expirationDate?: Date | null;
}
export interface ApiInviteAssignment {
    policy?: AssignedPolicy;
    restrictions?: Restriction;
}
export interface GetPoliciesRequest {
    /** The locale of the request. Defaults to en */
    locale?: string | null;
    /** Areas filter to include only roles from areas that pass this filter. When not provided, roles from all areas will be returned */
    areasFilter?: AreasFilter;
    /** Role level filter to include only roles that are not restricted from the requested resource level (site/account). When set to ALL, all levels are returned */
    roleLevel?: RoleLevel;
}
export interface AreasFilter {
    /** A list of role area ids, to filter only roles belonging to these areas */
    areaIds?: string[];
}
export declare enum RoleLevel {
    ALL = "ALL",
    SITE_LEVEL = "SITE_LEVEL",
    ACCOUNT_LEVEL = "ACCOUNT_LEVEL"
}
export interface GetPoliciesResponse {
    policies?: PredefinedRoles;
}
export interface SearchTeamRequest {
    /** Free text to search for within team member name and email address fields. */
    query?: string | null;
    /** Sort data. */
    orderBy?: Ordering[];
    /**
     * Filter object. Supported values: `inviteType` and `roleId`. For example, `{'inviteType': {'$eq': 'Expired'}}`.
     * See [API Query Language](https://dev.wix.com/api/rest/getting-started/api-query-language) for more information.
     */
    filter?: Record<string, any> | null;
    /**
     * A list of facets to return in the response. Facets count the items within logical groupings.
     * See [Filters and Facets: An Explainer](https://medium.com/@westontt/filters-and-facets-an-explainer-3b73a9538eca) for more information.
     */
    facets?: FacetType[];
    /** Pagination. */
    paging?: Paging;
}
export interface Ordering {
    /** Field to sort by. */
    fieldName?: OrderField;
    /** Sort order. */
    direction?: Direction;
}
export declare enum OrderField {
    /** For internal use. */
    Undefined = "Undefined",
    /** Team member name. */
    Name = "Name",
    /** Date team member joined the account. */
    JoinedAt = "JoinedAt"
}
export declare enum Direction {
    /** For internal use. */
    UninitializedDirection = "UninitializedDirection",
    /** Ascending. */
    ASC = "ASC",
    /** Descending. */
    DESC = "DESC"
}
export declare enum FacetType {
    Undefined = "Undefined",
    /** How many team members with each role */
    Roles = "Roles",
    /** How many team members by invite status */
    InviteStatus = "InviteStatus",
    /** How many team members in total in the account */
    Users = "Users"
}
export interface SearchTeamResponse {
    /** List of facets, as requested. */
    facets?: Facet[];
    /** Existing team members and invites sent to join the account. */
    teamMembers?: TeamMemberV3[];
}
export interface Facet {
    /** Facet type. */
    facetType?: FacetType;
    /** Values and their counters. Values with count = 0 are not returned. */
    values?: FacetValue[];
}
export interface FacetValue {
    /** Supported values: `Roles`, `InviteStatus`, `Users`. */
    value?: string;
    /** Number of existing items for the value. */
    count?: number;
}
export interface TeamMemberV3 extends TeamMemberV3MembersOneOf {
    /** Existing team member data. */
    user?: UserV3;
    /** Invited team member data. */
    invite?: InviteV3;
}
/** @oneof */
export interface TeamMemberV3MembersOneOf {
    /** Existing team member data. */
    user?: UserV3;
    /** Invited team member data. */
    invite?: InviteV3;
}
export interface UserV3 {
    /** User ID. */
    id?: string;
    /** User's email address. */
    email?: string | null;
    /** User's name, when provided. */
    name?: Name;
    /** URL to user's profile image, when provided. */
    profileImage?: string | null;
    /** Date the user joined the team. */
    joinedTeamAt?: Date | null;
    /** Mapping of the user's access to an asset and their assigned role. */
    assignments?: AssignmentV3[];
}
export interface AssignmentV3 {
    /** Role assigned to the user. To retrieve all available roles, call Get Roles Info. */
    policyId?: string | null;
    /**
     * Unique ID for this specific assignment.
     * @readonly
     */
    assignmentId?: string | null;
    /** The asset where a user is assigned access in an assignment. When empty, the role covers all assets, with no restrictions to specific sites or folders. */
    restrictions?: Restriction;
    /** Identity assigned to the asset in an assignment, referred to as subject. Supported subjects include user IDs, account IDs, and app IDs. */
    subject?: AssignedSubject;
}
export interface AssignedSubject {
    /**
     * Identity ID.
     * @readonly
     */
    id?: string;
    /** Identity type. */
    subjectType?: SubjectType;
}
export interface InviteV3 {
    /**
     * Invite ID.
     * @readonly
     */
    id?: string;
    /** Invitee's email address. */
    email?: string | null;
    /** Invite status. */
    status?: InviteStatus;
    /** URL of direct link to accept the invite. */
    acceptLink?: string | null;
    /** Date the invite was created. */
    dateCreated?: Date | null;
    /** Date the invite was last updated. */
    dateUpdated?: Date | null;
    /** A list of assignments that will be applied to the invitees when they accept the invite. */
    assignments?: InviteAssignmentV3[];
    /** Invite expiration date. */
    expirationDate?: Date | null;
}
export interface InviteAssignmentV3 {
    /** Role ID that will be assigned once the invite is accepted. */
    policyId?: string | null;
    /** Assets where the user will be assigned access. When empty, the role covers all assets, with no restrictions to specific sites or folders. */
    restrictions?: Restriction;
}
export interface GetRolesRequest {
    /** The locale of the predefined roles names and descriptions. Defaults to English */
    locale?: string | null;
}
export interface GetRolesResponse {
    /** The predefined roles (by areas) */
    predefinedRolesAreas?: PredefinedRolesArea[];
    /** The custom roles */
    customRoles?: CustomRole[];
}
export interface PredefinedRolesArea {
    /** The id of the area (e.g "Blog") */
    areaId?: string;
    /** The translated area title, according to the request locale, or the original title if translation failed */
    title?: string;
    /** The predefined roles belonging to this area */
    roles?: PredefinedRoleV2[];
}
export interface PredefinedRoleV2 {
    /** The policy id of this role */
    id?: string;
    /** The title of this role, translated according to the request locale, or the original title if translation failed */
    title?: string;
    /** The description of this role, translated according to the request locale, or the original description if translation failed */
    description?: string;
    /** The permission-scopes this role's policy contains */
    scopes?: string[];
    /** Indicates if the role is deprecated (shouldn't be granted, and only exists for backward compatability) */
    deprecated?: boolean;
    /** Indicates if this role should be restricted from assignments of a specific resource type (if RoleLevelRestriction = None, there is no restriction) */
    restrictFromLevel?: RoleLevelRestriction;
    /** Experiments that should be open for this role to be visible */
    experiments?: string[];
    /** Applications that should be installed for this role to be visible */
    appDefIds?: string[];
    /** Editor types this role should be limited to (if empty, available in all editors) */
    limitToEditorTypes?: EditorType[];
    /** The visibility of the role */
    visibility?: RoleVisibility;
}
export declare enum RoleLevelRestriction {
    NoRestriction = "NoRestriction",
    Site = "Site",
    Account = "Account"
}
export declare enum EditorType {
    UNINITIALIZED = "UNINITIALIZED",
    EDITORX = "EDITORX",
    BLOCKS = "BLOCKS",
    STUDIO = "STUDIO"
}
export declare enum RoleVisibility {
    /** the role should be visible to the caller */
    Visible = "Visible",
    /** the role should be disabled for the caller, because it contains permissions the caller wasn't granted on the call context (site/account) */
    Disabled_Dependency = "Disabled_Dependency",
    /** the role should be disabled for the caller, because the role's capability is disabled for the caller */
    Disabled_Capability = "Disabled_Capability"
}
export interface CustomRole {
    /** The policy this role grants */
    policy?: ApiPolicy;
    /** The visibility of the role */
    visibility?: RoleVisibility;
}
export interface GetRolesInfoRequest {
    /** Language of predefined roles names and descriptions to return, in ISO 639 format. Default: `en`. */
    locale?: string | null;
    /** Roles to return. */
    filter?: RolesInfoFilter;
}
export interface RolesInfoFilter {
    /** Role level to return. Default: ALL. */
    roleLevel?: RoleLevel;
    /** Filter for editor-specific roles. Default: ALL. */
    editorTypes?: EditorType[];
}
export interface GetRolesInfoResponse {
    /** Predefined roles. */
    predefinedRoles?: RoleInfo[];
    /** Custom roles. */
    customRoles?: RoleInfo[];
}
export interface RoleInfo {
    /** Role ID. */
    id?: string;
    /** Role title, translated according to the request locale. If translation fails, the original title is returned. */
    title?: string;
    /** Role description, translated according to the request locale. If translation fails, the original description is returned. */
    description?: string;
    /** Whether this role is restricted from accessing a specific resource type. Default: `NoRestriction`. */
    restrictFromLevel?: RoleLevelRestriction;
}
export interface CreateCustomRoleRequest {
    /** The custom role to create */
    role?: Policy;
}
export interface Policy {
    /** @readonly */
    id?: string | null;
    name?: string | null;
    description?: string | null;
    /** @readonly */
    status?: string;
    policyType?: PolicyType;
    statements?: PolicyStatement[];
}
export declare enum PolicyType {
    UNKNOWN_STATUS = "UNKNOWN_STATUS",
    PREDEFINED = "PREDEFINED",
    CUSTOM = "CUSTOM",
    INLINE_CUSTOM = "INLINE_CUSTOM"
}
export interface PolicyStatement {
    /** @readonly */
    id?: string | null;
    permissions?: string[];
    scopes?: string[];
    effect?: Effect;
    condition?: PolicyCondition;
}
export declare enum Effect {
    UNKNOWN_EFFECT = "UNKNOWN_EFFECT",
    ALLOW = "ALLOW",
    DENY = "DENY"
}
export interface CreateCustomRoleResponse {
    /** The newly created custom role */
    roleCreated?: Policy;
}
export interface ChangeRoleV2Request {
    /** ID of team member being affected. */
    userId?: string;
    /** New assignments, including roles, to apply to the team member in this account. To retrieve all available roles, call Get Roles Info. */
    roles?: AssignmentV3[];
    /** Existing assignment IDs to remove. To retrieve all existing assignment IDs for a team member, call Search Team. */
    assignmentIdsToReplace?: string[];
}
export interface ChangeRoleV2Response {
    /** New roles assigned to the given team member. */
    roles?: AssignmentV3[];
}
export interface UpdateTeamMemberAssignmentsRequest {
    /** ID of team member being affected. */
    userId: string;
    /** New assignments to apply to the team member in this account. */
    newAssignments: AssignmentV3[];
    /** Existing assignment IDs to remove. To retrieve all existing assignment IDs for a team member, call Search Team. */
    assignmentIdsToRemove: string[];
}
export interface UpdateTeamMemberAssignmentsResponse {
    /** The new assignments, assigned to the given team member. */
    assignments?: AssignmentV3[];
}
export interface GetSubjectsAssignmentsRequest {
    /** The locale of the request. Defaults to en */
    locale?: string | null;
    /** list of subjects */
    subjects?: Subject[];
}
export interface GetSubjectsAssignmentsResponse {
    /** list of subjects with assignments */
    subjectsAssignments?: SubjectAssignments[];
}
export interface SubjectAssignments {
    subject?: Subject;
    assignments?: Assignment[];
}
interface FacetValueNonNullableFields {
    value: string;
    count: number;
}
interface FacetNonNullableFields {
    facetType: FacetType;
    values: FacetValueNonNullableFields[];
}
interface NameNonNullableFields {
    firstName: string;
    lastName: string;
}
interface ApiResourceNonNullableFields {
    resourceType: ResourceType;
    id: string;
}
interface ApiConditionNonNullableFields {
    conditionType: ConditionAttributeType;
    id: string;
}
interface ConditionsNonNullableFields {
    conditions: ApiConditionNonNullableFields[];
}
interface CompanionResourceNonNullableFields {
    id: string;
    resourceType: string;
}
interface SiteRestrictionNonNullableFields {
    id: string;
    resource?: CompanionResourceNonNullableFields;
}
interface RestrictionNonNullableFields {
    resource?: ApiResourceNonNullableFields;
    conditions?: ConditionsNonNullableFields;
    site?: SiteRestrictionNonNullableFields;
}
interface AssignedSubjectNonNullableFields {
    id: string;
    subjectType: SubjectType;
}
interface AssignmentV3NonNullableFields {
    restrictions?: RestrictionNonNullableFields;
    subject?: AssignedSubjectNonNullableFields;
}
interface UserV3NonNullableFields {
    id: string;
    name?: NameNonNullableFields;
    assignments: AssignmentV3NonNullableFields[];
}
interface InviteAssignmentV3NonNullableFields {
    restrictions?: RestrictionNonNullableFields;
}
interface InviteV3NonNullableFields {
    id: string;
    status: InviteStatus;
    assignments: InviteAssignmentV3NonNullableFields[];
}
interface TeamMemberV3NonNullableFields {
    user?: UserV3NonNullableFields;
    invite?: InviteV3NonNullableFields;
}
export interface SearchTeamResponseNonNullableFields {
    facets: FacetNonNullableFields[];
    teamMembers: TeamMemberV3NonNullableFields[];
}
interface RoleInfoNonNullableFields {
    id: string;
    title: string;
    description: string;
    restrictFromLevel: RoleLevelRestriction;
}
export interface GetRolesInfoResponseNonNullableFields {
    predefinedRoles: RoleInfoNonNullableFields[];
    customRoles: RoleInfoNonNullableFields[];
}
export interface UpdateTeamMemberAssignmentsResponseNonNullableFields {
    assignments: AssignmentV3NonNullableFields[];
}
export {};