/* tslint:disable */
/* eslint-disable */
/**
 * Identity Security Cloud API - Data Segmentation
 * Use these APIs to interact with the Identity Security Cloud platform to achieve repeatable, automated processes with greater scalability. We encourage you to join the SailPoint Developer Community forum at https://developer.sailpoint.com/discuss to connect with other developers using our APIs.
 *
 * The version of the OpenAPI document: v1
 * 
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
 * https://openapi-generator.tech
 * Do not edit the class manually.
 */


import type { Configuration } from '../configuration';
import type { AxiosPromise, AxiosInstance, RawAxiosRequestConfig } from 'axios';
import globalAxios from 'axios';
// Some imports not used depending on template conditions
// @ts-ignore
import { DUMMY_BASE_URL, assertParamExists, setApiKeyToObject, setBasicAuthToObject, setBearerAuthToObject, setOAuthToObject, setSearchParams, serializeDataIfNeeded, toPathString, createRequestFunction } from './common';
import type { RequestArgs } from './base';
// @ts-ignore
import { BASE_PATH, COLLECTION_FORMATS, BaseAPI, RequiredError, operationServerMap } from './base';

/**
 * 
 * @export
 * @interface DataSegment
 */
export interface DataSegment {
    /**
     * The segment\'s ID.
     * @type {string}
     * @memberof DataSegment
     */
    'id'?: string;
    /**
     * The segment\'s business name.
     * @type {string}
     * @memberof DataSegment
     */
    'name'?: string;
    /**
     * The time when the segment is created.
     * @type {string}
     * @memberof DataSegment
     */
    'created'?: string;
    /**
     * The time when the segment is modified.
     * @type {string}
     * @memberof DataSegment
     */
    'modified'?: string;
    /**
     * The segment\'s optional description.
     * @type {string}
     * @memberof DataSegment
     */
    'description'?: string;
    /**
     * List of Scopes that are assigned to the segment
     * @type {Array<Scope>}
     * @memberof DataSegment
     */
    'scopes'?: Array<Scope>;
    /**
     * List of Identities that are assigned to the segment
     * @type {Array<Ref>}
     * @memberof DataSegment
     */
    'memberSelection'?: Array<Ref>;
    /**
     * 
     * @type {VisibilityCriteria}
     * @memberof DataSegment
     */
    'memberFilter'?: VisibilityCriteria;
    /**
     * 
     * @type {MembershipType}
     * @memberof DataSegment
     */
    'membership'?: MembershipType;
    /**
     * This boolean indicates whether the segment is currently active. Inactive segments have no effect.
     * @type {boolean}
     * @memberof DataSegment
     */
    'enabled'?: boolean;
    /**
     * This boolean indicates whether the segment is being applied to the accounts. If unpublished its being actively modified to until published
     * @type {boolean}
     * @memberof DataSegment
     */
    'published'?: boolean;
}


/**
 * An enumeration of the types of DTOs supported within the IdentityNow infrastructure.
 * @export
 * @enum {string}
 */

export const DtoType = {
    AccountCorrelationConfig: 'ACCOUNT_CORRELATION_CONFIG',
    AccessProfile: 'ACCESS_PROFILE',
    AccessRequestApproval: 'ACCESS_REQUEST_APPROVAL',
    Account: 'ACCOUNT',
    Application: 'APPLICATION',
    Campaign: 'CAMPAIGN',
    CampaignFilter: 'CAMPAIGN_FILTER',
    Certification: 'CERTIFICATION',
    Cluster: 'CLUSTER',
    ConnectorSchema: 'CONNECTOR_SCHEMA',
    Entitlement: 'ENTITLEMENT',
    GovernanceGroup: 'GOVERNANCE_GROUP',
    Identity: 'IDENTITY',
    IdentityProfile: 'IDENTITY_PROFILE',
    IdentityRequest: 'IDENTITY_REQUEST',
    MachineIdentity: 'MACHINE_IDENTITY',
    LifecycleState: 'LIFECYCLE_STATE',
    PasswordPolicy: 'PASSWORD_POLICY',
    Role: 'ROLE',
    Rule: 'RULE',
    SodPolicy: 'SOD_POLICY',
    Source: 'SOURCE',
    Tag: 'TAG',
    TagCategory: 'TAG_CATEGORY',
    TaskResult: 'TASK_RESULT',
    ReportResult: 'REPORT_RESULT',
    SodViolation: 'SOD_VIOLATION',
    AccountActivity: 'ACCOUNT_ACTIVITY',
    Workgroup: 'WORKGROUP'
} as const;

export type DtoType = typeof DtoType[keyof typeof DtoType];


/**
 * 
 * @export
 * @interface ErrorMessageDto
 */
export interface ErrorMessageDto {
    /**
     * The locale for the message text, a BCP 47 language tag.
     * @type {string}
     * @memberof ErrorMessageDto
     */
    'locale'?: string | null;
    /**
     * 
     * @type {LocaleOrigin}
     * @memberof ErrorMessageDto
     */
    'localeOrigin'?: LocaleOrigin | null;
    /**
     * Actual text of the error message in the indicated locale.
     * @type {string}
     * @memberof ErrorMessageDto
     */
    'text'?: string;
}


/**
 * 
 * @export
 * @interface ErrorResponseDto
 */
export interface ErrorResponseDto {
    /**
     * Fine-grained error code providing more detail of the error.
     * @type {string}
     * @memberof ErrorResponseDto
     */
    'detailCode'?: string;
    /**
     * Unique tracking id for the error.
     * @type {string}
     * @memberof ErrorResponseDto
     */
    'trackingId'?: string;
    /**
     * Generic localized reason for error
     * @type {Array<ErrorMessageDto>}
     * @memberof ErrorResponseDto
     */
    'messages'?: Array<ErrorMessageDto>;
    /**
     * Plain-text descriptive reasons to provide additional detail to the text provided in the messages field
     * @type {Array<ErrorMessageDto>}
     * @memberof ErrorResponseDto
     */
    'causes'?: Array<ErrorMessageDto>;
}
/**
 * 
 * @export
 * @interface Expression
 */
export interface Expression {
    /**
     * Operator for the expression
     * @type {string}
     * @memberof Expression
     */
    'operator'?: ExpressionOperatorEnum;
    /**
     * Name for the attribute
     * @type {string}
     * @memberof Expression
     */
    'attribute'?: string | null;
    /**
     * 
     * @type {Value}
     * @memberof Expression
     */
    'value'?: Value | null;
    /**
     * List of expressions
     * @type {Array<ExpressionChildrenInner>}
     * @memberof Expression
     */
    'children'?: Array<ExpressionChildrenInner> | null;
}

export const ExpressionOperatorEnum = {
    And: 'AND',
    Equals: 'EQUALS'
} as const;

export type ExpressionOperatorEnum = typeof ExpressionOperatorEnum[keyof typeof ExpressionOperatorEnum];

/**
 * 
 * @export
 * @interface ExpressionChildrenInner
 */
export interface ExpressionChildrenInner {
    /**
     * Operator for the expression
     * @type {string}
     * @memberof ExpressionChildrenInner
     */
    'operator'?: ExpressionChildrenInnerOperatorEnum;
    /**
     * Name for the attribute
     * @type {string}
     * @memberof ExpressionChildrenInner
     */
    'attribute'?: string | null;
    /**
     * 
     * @type {Value}
     * @memberof ExpressionChildrenInner
     */
    'value'?: Value | null;
    /**
     * There cannot be anymore nested children. This will always be null.
     * @type {string}
     * @memberof ExpressionChildrenInner
     */
    'children'?: string | null;
}

export const ExpressionChildrenInnerOperatorEnum = {
    And: 'AND',
    Equals: 'EQUALS'
} as const;

export type ExpressionChildrenInnerOperatorEnum = typeof ExpressionChildrenInnerOperatorEnum[keyof typeof ExpressionChildrenInnerOperatorEnum];

/**
 * 
 * @export
 * @interface GetDataSegmentIdentityMembershipV1401Response
 */
export interface GetDataSegmentIdentityMembershipV1401Response {
    /**
     * A message describing the error
     * @type {any}
     * @memberof GetDataSegmentIdentityMembershipV1401Response
     */
    'error'?: any;
}
/**
 * 
 * @export
 * @interface GetDataSegmentIdentityMembershipV1429Response
 */
export interface GetDataSegmentIdentityMembershipV1429Response {
    /**
     * A message describing the error
     * @type {any}
     * @memberof GetDataSegmentIdentityMembershipV1429Response
     */
    'message'?: any;
}
/**
 * An indicator of how the locale was selected. *DEFAULT* means the locale is the system default. *REQUEST* means the locale was selected from the request context (i.e., best match based on the *Accept-Language* header). Additional values may be added in the future without notice.
 * @export
 * @enum {string}
 */

export const LocaleOrigin = {
    Default: 'DEFAULT',
    Request: 'REQUEST'
} as const;

export type LocaleOrigin = typeof LocaleOrigin[keyof typeof LocaleOrigin];


/**
 * An enumeration of the types of membership choices
 * @export
 * @enum {string}
 */

export const MembershipType = {
    All: 'ALL',
    Filter: 'FILTER',
    Selection: 'SELECTION'
} as const;

export type MembershipType = typeof MembershipType[keyof typeof MembershipType];


/**
 * 
 * @export
 * @interface Ref
 */
export interface Ref {
    /**
     * 
     * @type {DtoType}
     * @memberof Ref
     */
    'type'?: DtoType;
    /**
     * ID of the object to which this reference applies
     * @type {string}
     * @memberof Ref
     */
    'id'?: string;
}


/**
 * This defines what access the segment is giving
 * @export
 * @interface Scope
 */
export interface Scope {
    /**
     * 
     * @type {ScopeType}
     * @memberof Scope
     */
    'scope'?: ScopeType;
    /**
     * 
     * @type {ScopeVisibilityType}
     * @memberof Scope
     */
    'visibility'?: ScopeVisibilityType;
    /**
     * 
     * @type {VisibilityCriteria}
     * @memberof Scope
     */
    'scopeFilter'?: VisibilityCriteria;
    /**
     * List of Identities that are assigned to the segment
     * @type {Array<Ref>}
     * @memberof Scope
     */
    'scopeSelection'?: Array<Ref>;
}


/**
 * An enumeration of the types of scope choices
 * @export
 * @enum {string}
 */

export const ScopeType = {
    Entitlement: 'ENTITLEMENT',
    Certification: 'CERTIFICATION',
    Identity: 'IDENTITY',
    Entitlementrequest: 'ENTITLEMENTREQUEST'
} as const;

export type ScopeType = typeof ScopeType[keyof typeof ScopeType];


/**
 * An enumeration of the types of scope visibility choices
 * @export
 * @enum {string}
 */

export const ScopeVisibilityType = {
    All: 'ALL',
    Filter: 'FILTER',
    Selection: 'SELECTION',
    Unsegmented: 'UNSEGMENTED'
} as const;

export type ScopeVisibilityType = typeof ScopeVisibilityType[keyof typeof ScopeVisibilityType];


/**
 * Contains the segments and types that an identity is associated with
 * @export
 * @interface SegmentMembership
 */
export interface SegmentMembership {
    /**
     * List of segment ids that the identity is associated with.
     * @type {Array<string>}
     * @memberof SegmentMembership
     */
    'segments'?: Array<string>;
    /**
     * They type of scopes that are assigned to the identity.
     * @type {Array<ScopeType>}
     * @memberof SegmentMembership
     */
    'allAccessScopes'?: Array<ScopeType>;
    /**
     * Date time string that lets you know when the membership data is going to be refreshed.
     * @type {string}
     * @memberof SegmentMembership
     */
    'refreshBy'?: string;
}
/**
 * 
 * @export
 * @interface Value
 */
export interface Value {
    /**
     * The type of attribute value
     * @type {string}
     * @memberof Value
     */
    'type'?: string;
    /**
     * The attribute value
     * @type {string}
     * @memberof Value
     */
    'value'?: string;
}
/**
 * 
 * @export
 * @interface VisibilityCriteria
 */
export interface VisibilityCriteria {
    /**
     * 
     * @type {Expression}
     * @memberof VisibilityCriteria
     */
    'expression'?: Expression;
}

/**
 * DataSegmentationApi - axios parameter creator
 * @export
 */
export const DataSegmentationApiAxiosParamCreator = function (configuration?: Configuration) {
    return {
        /**
         * This API creates a segment.  >**Note:** Segment definitions may take time to propagate to all identities.
         * @summary Create segment
         * @param {DataSegment} dataSegment 
         * @param {string} [xSailPointExperimental] Use this header to enable this experimental API.
         * @param {*} [axiosOptions] Override http request option.
         * @throws {RequiredError}
         */
        createDataSegmentV1: async (dataSegment: DataSegment, xSailPointExperimental?: string, axiosOptions: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
            // verify required parameter 'dataSegment' is not null or undefined
            assertParamExists('createDataSegmentV1', 'dataSegment', dataSegment)
            if (xSailPointExperimental === undefined) {
                xSailPointExperimental = 'true';
            }
            
            const localVarPath = `/data-segments/v1`;
            // use dummy base URL string because the URL constructor only accepts absolute URLs.
            const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
            let baseOptions;
            if (configuration) {
                baseOptions = configuration.baseOptions;
            }

            const localVarRequestOptions = { method: 'POST', ...baseOptions, ...axiosOptions};
            const localVarHeaderParameter = {} as any;
            const localVarQueryParameter = {} as any;


    
            localVarHeaderParameter['Content-Type'] = 'application/json';

            if (xSailPointExperimental != null) {
                localVarHeaderParameter['X-SailPoint-Experimental'] = String(xSailPointExperimental);
            }
            setSearchParams(localVarUrlObj, localVarQueryParameter);
            let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
            localVarRequestOptions.headers = {...localVarHeaderParameter, ...headersFromBaseOptions, ...axiosOptions.headers};
            localVarRequestOptions.data = serializeDataIfNeeded(dataSegment, localVarRequestOptions, configuration)

            return {
                url: toPathString(localVarUrlObj),
                axiosOptions: localVarRequestOptions,
            };
        },
        /**
         * This API deletes the segment specified by the given ID.
         * @summary Delete segment by id
         * @param {string} segmentId The segment ID to delete.
         * @param {boolean} [published] This determines which version of the segment to delete
         * @param {string} [xSailPointExperimental] Use this header to enable this experimental API.
         * @param {*} [axiosOptions] Override http request option.
         * @throws {RequiredError}
         */
        deleteDataSegmentV1: async (segmentId: string, published?: boolean, xSailPointExperimental?: string, axiosOptions: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
            // verify required parameter 'segmentId' is not null or undefined
            assertParamExists('deleteDataSegmentV1', 'segmentId', segmentId)
            if (xSailPointExperimental === undefined) {
                xSailPointExperimental = 'true';
            }
            
            const localVarPath = `/data-segments/v1/{segmentId}`
                .replace(`{${"segmentId"}}`, encodeURIComponent(String(segmentId)));
            // use dummy base URL string because the URL constructor only accepts absolute URLs.
            const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
            let baseOptions;
            if (configuration) {
                baseOptions = configuration.baseOptions;
            }

            const localVarRequestOptions = { method: 'DELETE', ...baseOptions, ...axiosOptions};
            const localVarHeaderParameter = {} as any;
            const localVarQueryParameter = {} as any;

            if (published !== undefined) {
                localVarQueryParameter['published'] = published;
            }


    
            if (xSailPointExperimental != null) {
                localVarHeaderParameter['X-SailPoint-Experimental'] = String(xSailPointExperimental);
            }
            setSearchParams(localVarUrlObj, localVarQueryParameter);
            let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
            localVarRequestOptions.headers = {...localVarHeaderParameter, ...headersFromBaseOptions, ...axiosOptions.headers};

            return {
                url: toPathString(localVarUrlObj),
                axiosOptions: localVarRequestOptions,
            };
        },
        /**
         * This API returns the segment membership specified by the given identity ID.
         * @summary Get segmentmembership by identity id
         * @param {string} identityId The identity ID to retrieve the segments they are in.
         * @param {string} [xSailPointExperimental] Use this header to enable this experimental API.
         * @param {*} [axiosOptions] Override http request option.
         * @throws {RequiredError}
         */
        getDataSegmentIdentityMembershipV1: async (identityId: string, xSailPointExperimental?: string, axiosOptions: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
            // verify required parameter 'identityId' is not null or undefined
            assertParamExists('getDataSegmentIdentityMembershipV1', 'identityId', identityId)
            if (xSailPointExperimental === undefined) {
                xSailPointExperimental = 'true';
            }
            
            const localVarPath = `/data-segments/v1/membership/{identityId}`
                .replace(`{${"identityId"}}`, encodeURIComponent(String(identityId)));
            // use dummy base URL string because the URL constructor only accepts absolute URLs.
            const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
            let baseOptions;
            if (configuration) {
                baseOptions = configuration.baseOptions;
            }

            const localVarRequestOptions = { method: 'GET', ...baseOptions, ...axiosOptions};
            const localVarHeaderParameter = {} as any;
            const localVarQueryParameter = {} as any;


    
            if (xSailPointExperimental != null) {
                localVarHeaderParameter['X-SailPoint-Experimental'] = String(xSailPointExperimental);
            }
            setSearchParams(localVarUrlObj, localVarQueryParameter);
            let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
            localVarRequestOptions.headers = {...localVarHeaderParameter, ...headersFromBaseOptions, ...axiosOptions.headers};

            return {
                url: toPathString(localVarUrlObj),
                axiosOptions: localVarRequestOptions,
            };
        },
        /**
         * This API returns the segment specified by the given ID.
         * @summary Get segment by id
         * @param {string} segmentId The segment ID to retrieve.
         * @param {string} [xSailPointExperimental] Use this header to enable this experimental API.
         * @param {*} [axiosOptions] Override http request option.
         * @throws {RequiredError}
         */
        getDataSegmentV1: async (segmentId: string, xSailPointExperimental?: string, axiosOptions: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
            // verify required parameter 'segmentId' is not null or undefined
            assertParamExists('getDataSegmentV1', 'segmentId', segmentId)
            if (xSailPointExperimental === undefined) {
                xSailPointExperimental = 'true';
            }
            
            const localVarPath = `/data-segments/v1/{segmentId}`
                .replace(`{${"segmentId"}}`, encodeURIComponent(String(segmentId)));
            // use dummy base URL string because the URL constructor only accepts absolute URLs.
            const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
            let baseOptions;
            if (configuration) {
                baseOptions = configuration.baseOptions;
            }

            const localVarRequestOptions = { method: 'GET', ...baseOptions, ...axiosOptions};
            const localVarHeaderParameter = {} as any;
            const localVarQueryParameter = {} as any;


    
            if (xSailPointExperimental != null) {
                localVarHeaderParameter['X-SailPoint-Experimental'] = String(xSailPointExperimental);
            }
            setSearchParams(localVarUrlObj, localVarQueryParameter);
            let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
            localVarRequestOptions.headers = {...localVarHeaderParameter, ...headersFromBaseOptions, ...axiosOptions.headers};

            return {
                url: toPathString(localVarUrlObj),
                axiosOptions: localVarRequestOptions,
            };
        },
        /**
         * This API returns whether or not segmentation is enabled for the identity.
         * @summary Is segmentation enabled by identity
         * @param {string} identityId The identity ID to retrieve if segmentation is enabled for the identity.
         * @param {string} [xSailPointExperimental] Use this header to enable this experimental API.
         * @param {*} [axiosOptions] Override http request option.
         * @throws {RequiredError}
         */
        getDataSegmentationEnabledForUserV1: async (identityId: string, xSailPointExperimental?: string, axiosOptions: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
            // verify required parameter 'identityId' is not null or undefined
            assertParamExists('getDataSegmentationEnabledForUserV1', 'identityId', identityId)
            if (xSailPointExperimental === undefined) {
                xSailPointExperimental = 'true';
            }
            
            const localVarPath = `/data-segments/v1/user-enabled/{identityId}`
                .replace(`{${"identityId"}}`, encodeURIComponent(String(identityId)));
            // use dummy base URL string because the URL constructor only accepts absolute URLs.
            const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
            let baseOptions;
            if (configuration) {
                baseOptions = configuration.baseOptions;
            }

            const localVarRequestOptions = { method: 'GET', ...baseOptions, ...axiosOptions};
            const localVarHeaderParameter = {} as any;
            const localVarQueryParameter = {} as any;


    
            if (xSailPointExperimental != null) {
                localVarHeaderParameter['X-SailPoint-Experimental'] = String(xSailPointExperimental);
            }
            setSearchParams(localVarUrlObj, localVarQueryParameter);
            let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
            localVarRequestOptions.headers = {...localVarHeaderParameter, ...headersFromBaseOptions, ...axiosOptions.headers};

            return {
                url: toPathString(localVarUrlObj),
                axiosOptions: localVarRequestOptions,
            };
        },
        /**
         * This API returns the segment specified by the given ID.
         * @summary Get segments
         * @param {boolean} [enabled] This boolean indicates whether the segment is currently active. Inactive segments have no effect.
         * @param {boolean} [unique] This returns only one record if set to true and that would be the published record if exists.
         * @param {boolean} [published] This boolean indicates whether the segment is being applied to the accounts. If unpublished its being actively modified until published
         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **id**: *eq, in, sw*  **name**: *eq, in, sw*
         * @param {string} [xSailPointExperimental] Use this header to enable this experimental API.
         * @param {*} [axiosOptions] Override http request option.
         * @throws {RequiredError}
         */
        listDataSegmentsV1: async (enabled?: boolean, unique?: boolean, published?: boolean, limit?: number, offset?: number, count?: boolean, filters?: string, xSailPointExperimental?: string, axiosOptions: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
            if (xSailPointExperimental === undefined) {
                xSailPointExperimental = 'true';
            }
            
            const localVarPath = `/data-segments/v1`;
            // use dummy base URL string because the URL constructor only accepts absolute URLs.
            const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
            let baseOptions;
            if (configuration) {
                baseOptions = configuration.baseOptions;
            }

            const localVarRequestOptions = { method: 'GET', ...baseOptions, ...axiosOptions};
            const localVarHeaderParameter = {} as any;
            const localVarQueryParameter = {} as any;

            if (enabled !== undefined) {
                localVarQueryParameter['enabled'] = enabled;
            }

            if (unique !== undefined) {
                localVarQueryParameter['unique'] = unique;
            }

            if (published !== undefined) {
                localVarQueryParameter['published'] = published;
            }

            if (limit !== undefined) {
                localVarQueryParameter['limit'] = limit;
            }

            if (offset !== undefined) {
                localVarQueryParameter['offset'] = offset;
            }

            if (count !== undefined) {
                localVarQueryParameter['count'] = count;
            }

            if (filters !== undefined) {
                localVarQueryParameter['filters'] = filters;
            }


    
            if (xSailPointExperimental != null) {
                localVarHeaderParameter['X-SailPoint-Experimental'] = String(xSailPointExperimental);
            }
            setSearchParams(localVarUrlObj, localVarQueryParameter);
            let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
            localVarRequestOptions.headers = {...localVarHeaderParameter, ...headersFromBaseOptions, ...axiosOptions.headers};

            return {
                url: toPathString(localVarUrlObj),
                axiosOptions: localVarRequestOptions,
            };
        },
        /**
         * Use this API to update segment fields by using the [JSON Patch](https://tools.ietf.org/html/rfc6902) standard.
         * @summary Update segment
         * @param {string} segmentId The segment ID to modify.
         * @param {Array<object>} requestBody A list of segment update operations according to the [JSON Patch](https://tools.ietf.org/html/rfc6902) standard.  The following fields are patchable: * name * description * membership * memberFilter * memberSelection * scopes * enabled 
         * @param {string} [xSailPointExperimental] Use this header to enable this experimental API.
         * @param {*} [axiosOptions] Override http request option.
         * @throws {RequiredError}
         */
        patchDataSegmentV1: async (segmentId: string, requestBody: Array<object>, xSailPointExperimental?: string, axiosOptions: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
            // verify required parameter 'segmentId' is not null or undefined
            assertParamExists('patchDataSegmentV1', 'segmentId', segmentId)
            // verify required parameter 'requestBody' is not null or undefined
            assertParamExists('patchDataSegmentV1', 'requestBody', requestBody)
            if (xSailPointExperimental === undefined) {
                xSailPointExperimental = 'true';
            }
            
            const localVarPath = `/data-segments/v1/{segmentId}`
                .replace(`{${"segmentId"}}`, encodeURIComponent(String(segmentId)));
            // use dummy base URL string because the URL constructor only accepts absolute URLs.
            const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
            let baseOptions;
            if (configuration) {
                baseOptions = configuration.baseOptions;
            }

            const localVarRequestOptions = { method: 'PATCH', ...baseOptions, ...axiosOptions};
            const localVarHeaderParameter = {} as any;
            const localVarQueryParameter = {} as any;


    
            localVarHeaderParameter['Content-Type'] = 'application/json-patch+json';

            if (xSailPointExperimental != null) {
                localVarHeaderParameter['X-SailPoint-Experimental'] = String(xSailPointExperimental);
            }
            setSearchParams(localVarUrlObj, localVarQueryParameter);
            let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
            localVarRequestOptions.headers = {...localVarHeaderParameter, ...headersFromBaseOptions, ...axiosOptions.headers};
            localVarRequestOptions.data = serializeDataIfNeeded(requestBody, localVarRequestOptions, configuration)

            return {
                url: toPathString(localVarUrlObj),
                axiosOptions: localVarRequestOptions,
            };
        },
        /**
         * This will publish the segment so that it starts applying the segmentation to the desired users if enabled
         * @summary Publish segment by id
         * @param {string} segmentId The segmentId.
         * @param {Array<string>} requestBody A list of segment ids that you wish to publish
         * @param {boolean} [publishAll] This flag decides whether you want to publish all unpublished or a list of specific segment ids
         * @param {string} [xSailPointExperimental] Use this header to enable this experimental API.
         * @param {*} [axiosOptions] Override http request option.
         * @throws {RequiredError}
         */
        publishDataSegmentV1: async (segmentId: string, requestBody: Array<string>, publishAll?: boolean, xSailPointExperimental?: string, axiosOptions: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
            // verify required parameter 'segmentId' is not null or undefined
            assertParamExists('publishDataSegmentV1', 'segmentId', segmentId)
            // verify required parameter 'requestBody' is not null or undefined
            assertParamExists('publishDataSegmentV1', 'requestBody', requestBody)
            if (xSailPointExperimental === undefined) {
                xSailPointExperimental = 'true';
            }
            
            const localVarPath = `/data-segments/v1/{segmentId}`
                .replace(`{${"segmentId"}}`, encodeURIComponent(String(segmentId)));
            // use dummy base URL string because the URL constructor only accepts absolute URLs.
            const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
            let baseOptions;
            if (configuration) {
                baseOptions = configuration.baseOptions;
            }

            const localVarRequestOptions = { method: 'POST', ...baseOptions, ...axiosOptions};
            const localVarHeaderParameter = {} as any;
            const localVarQueryParameter = {} as any;

            if (publishAll !== undefined) {
                localVarQueryParameter['publishAll'] = publishAll;
            }


    
            localVarHeaderParameter['Content-Type'] = 'application/json';

            if (xSailPointExperimental != null) {
                localVarHeaderParameter['X-SailPoint-Experimental'] = String(xSailPointExperimental);
            }
            setSearchParams(localVarUrlObj, localVarQueryParameter);
            let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
            localVarRequestOptions.headers = {...localVarHeaderParameter, ...headersFromBaseOptions, ...axiosOptions.headers};
            localVarRequestOptions.data = serializeDataIfNeeded(requestBody, localVarRequestOptions, configuration)

            return {
                url: toPathString(localVarUrlObj),
                axiosOptions: localVarRequestOptions,
            };
        },
    }
};

/**
 * DataSegmentationApi - functional programming interface
 * @export
 */
export const DataSegmentationApiFp = function(configuration?: Configuration) {
    const localVarAxiosParamCreator = DataSegmentationApiAxiosParamCreator(configuration)
    return {
        /**
         * This API creates a segment.  >**Note:** Segment definitions may take time to propagate to all identities.
         * @summary Create segment
         * @param {DataSegment} dataSegment 
         * @param {string} [xSailPointExperimental] Use this header to enable this experimental API.
         * @param {*} [axiosOptions] Override http request option.
         * @throws {RequiredError}
         */
        async createDataSegmentV1(dataSegment: DataSegment, xSailPointExperimental?: string, axiosOptions?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<DataSegment>> {
            const localVarAxiosArgs = await localVarAxiosParamCreator.createDataSegmentV1(dataSegment, xSailPointExperimental, axiosOptions);
            const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
            const localVarOperationServerBasePath = operationServerMap['DataSegmentationApi.createDataSegmentV1']?.[localVarOperationServerIndex]?.url;
            return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
        },
        /**
         * This API deletes the segment specified by the given ID.
         * @summary Delete segment by id
         * @param {string} segmentId The segment ID to delete.
         * @param {boolean} [published] This determines which version of the segment to delete
         * @param {string} [xSailPointExperimental] Use this header to enable this experimental API.
         * @param {*} [axiosOptions] Override http request option.
         * @throws {RequiredError}
         */
        async deleteDataSegmentV1(segmentId: string, published?: boolean, xSailPointExperimental?: string, axiosOptions?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<void>> {
            const localVarAxiosArgs = await localVarAxiosParamCreator.deleteDataSegmentV1(segmentId, published, xSailPointExperimental, axiosOptions);
            const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
            const localVarOperationServerBasePath = operationServerMap['DataSegmentationApi.deleteDataSegmentV1']?.[localVarOperationServerIndex]?.url;
            return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
        },
        /**
         * This API returns the segment membership specified by the given identity ID.
         * @summary Get segmentmembership by identity id
         * @param {string} identityId The identity ID to retrieve the segments they are in.
         * @param {string} [xSailPointExperimental] Use this header to enable this experimental API.
         * @param {*} [axiosOptions] Override http request option.
         * @throws {RequiredError}
         */
        async getDataSegmentIdentityMembershipV1(identityId: string, xSailPointExperimental?: string, axiosOptions?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<Array<SegmentMembership>>> {
            const localVarAxiosArgs = await localVarAxiosParamCreator.getDataSegmentIdentityMembershipV1(identityId, xSailPointExperimental, axiosOptions);
            const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
            const localVarOperationServerBasePath = operationServerMap['DataSegmentationApi.getDataSegmentIdentityMembershipV1']?.[localVarOperationServerIndex]?.url;
            return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
        },
        /**
         * This API returns the segment specified by the given ID.
         * @summary Get segment by id
         * @param {string} segmentId The segment ID to retrieve.
         * @param {string} [xSailPointExperimental] Use this header to enable this experimental API.
         * @param {*} [axiosOptions] Override http request option.
         * @throws {RequiredError}
         */
        async getDataSegmentV1(segmentId: string, xSailPointExperimental?: string, axiosOptions?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<DataSegment>> {
            const localVarAxiosArgs = await localVarAxiosParamCreator.getDataSegmentV1(segmentId, xSailPointExperimental, axiosOptions);
            const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
            const localVarOperationServerBasePath = operationServerMap['DataSegmentationApi.getDataSegmentV1']?.[localVarOperationServerIndex]?.url;
            return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
        },
        /**
         * This API returns whether or not segmentation is enabled for the identity.
         * @summary Is segmentation enabled by identity
         * @param {string} identityId The identity ID to retrieve if segmentation is enabled for the identity.
         * @param {string} [xSailPointExperimental] Use this header to enable this experimental API.
         * @param {*} [axiosOptions] Override http request option.
         * @throws {RequiredError}
         */
        async getDataSegmentationEnabledForUserV1(identityId: string, xSailPointExperimental?: string, axiosOptions?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<boolean>> {
            const localVarAxiosArgs = await localVarAxiosParamCreator.getDataSegmentationEnabledForUserV1(identityId, xSailPointExperimental, axiosOptions);
            const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
            const localVarOperationServerBasePath = operationServerMap['DataSegmentationApi.getDataSegmentationEnabledForUserV1']?.[localVarOperationServerIndex]?.url;
            return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
        },
        /**
         * This API returns the segment specified by the given ID.
         * @summary Get segments
         * @param {boolean} [enabled] This boolean indicates whether the segment is currently active. Inactive segments have no effect.
         * @param {boolean} [unique] This returns only one record if set to true and that would be the published record if exists.
         * @param {boolean} [published] This boolean indicates whether the segment is being applied to the accounts. If unpublished its being actively modified until published
         * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
         * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
         * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
         * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **id**: *eq, in, sw*  **name**: *eq, in, sw*
         * @param {string} [xSailPointExperimental] Use this header to enable this experimental API.
         * @param {*} [axiosOptions] Override http request option.
         * @throws {RequiredError}
         */
        async listDataSegmentsV1(enabled?: boolean, unique?: boolean, published?: boolean, limit?: number, offset?: number, count?: boolean, filters?: string, xSailPointExperimental?: string, axiosOptions?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<Array<DataSegment>>> {
            const localVarAxiosArgs = await localVarAxiosParamCreator.listDataSegmentsV1(enabled, unique, published, limit, offset, count, filters, xSailPointExperimental, axiosOptions);
            const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
            const localVarOperationServerBasePath = operationServerMap['DataSegmentationApi.listDataSegmentsV1']?.[localVarOperationServerIndex]?.url;
            return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
        },
        /**
         * Use this API to update segment fields by using the [JSON Patch](https://tools.ietf.org/html/rfc6902) standard.
         * @summary Update segment
         * @param {string} segmentId The segment ID to modify.
         * @param {Array<object>} requestBody A list of segment update operations according to the [JSON Patch](https://tools.ietf.org/html/rfc6902) standard.  The following fields are patchable: * name * description * membership * memberFilter * memberSelection * scopes * enabled 
         * @param {string} [xSailPointExperimental] Use this header to enable this experimental API.
         * @param {*} [axiosOptions] Override http request option.
         * @throws {RequiredError}
         */
        async patchDataSegmentV1(segmentId: string, requestBody: Array<object>, xSailPointExperimental?: string, axiosOptions?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<DataSegment>> {
            const localVarAxiosArgs = await localVarAxiosParamCreator.patchDataSegmentV1(segmentId, requestBody, xSailPointExperimental, axiosOptions);
            const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
            const localVarOperationServerBasePath = operationServerMap['DataSegmentationApi.patchDataSegmentV1']?.[localVarOperationServerIndex]?.url;
            return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
        },
        /**
         * This will publish the segment so that it starts applying the segmentation to the desired users if enabled
         * @summary Publish segment by id
         * @param {string} segmentId The segmentId.
         * @param {Array<string>} requestBody A list of segment ids that you wish to publish
         * @param {boolean} [publishAll] This flag decides whether you want to publish all unpublished or a list of specific segment ids
         * @param {string} [xSailPointExperimental] Use this header to enable this experimental API.
         * @param {*} [axiosOptions] Override http request option.
         * @throws {RequiredError}
         */
        async publishDataSegmentV1(segmentId: string, requestBody: Array<string>, publishAll?: boolean, xSailPointExperimental?: string, axiosOptions?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<void>> {
            const localVarAxiosArgs = await localVarAxiosParamCreator.publishDataSegmentV1(segmentId, requestBody, publishAll, xSailPointExperimental, axiosOptions);
            const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
            const localVarOperationServerBasePath = operationServerMap['DataSegmentationApi.publishDataSegmentV1']?.[localVarOperationServerIndex]?.url;
            return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
        },
    }
};

/**
 * DataSegmentationApi - factory interface
 * @export
 */
export const DataSegmentationApiFactory = function (configuration?: Configuration, basePath?: string, axios?: AxiosInstance) {
    const localVarFp = DataSegmentationApiFp(configuration)
    return {
        /**
         * This API creates a segment.  >**Note:** Segment definitions may take time to propagate to all identities.
         * @summary Create segment
         * @param {DataSegmentationApiCreateDataSegmentV1Request} requestParameters Request parameters.
         * @param {*} [axiosOptions] Override http request option.
         * @throws {RequiredError}
         */
        createDataSegmentV1(requestParameters: DataSegmentationApiCreateDataSegmentV1Request, axiosOptions?: RawAxiosRequestConfig): AxiosPromise<DataSegment> {
            return localVarFp.createDataSegmentV1(requestParameters.dataSegment, requestParameters.xSailPointExperimental, axiosOptions).then((request) => request(axios, basePath));
        },
        /**
         * This API deletes the segment specified by the given ID.
         * @summary Delete segment by id
         * @param {DataSegmentationApiDeleteDataSegmentV1Request} requestParameters Request parameters.
         * @param {*} [axiosOptions] Override http request option.
         * @throws {RequiredError}
         */
        deleteDataSegmentV1(requestParameters: DataSegmentationApiDeleteDataSegmentV1Request, axiosOptions?: RawAxiosRequestConfig): AxiosPromise<void> {
            return localVarFp.deleteDataSegmentV1(requestParameters.segmentId, requestParameters.published, requestParameters.xSailPointExperimental, axiosOptions).then((request) => request(axios, basePath));
        },
        /**
         * This API returns the segment membership specified by the given identity ID.
         * @summary Get segmentmembership by identity id
         * @param {DataSegmentationApiGetDataSegmentIdentityMembershipV1Request} requestParameters Request parameters.
         * @param {*} [axiosOptions] Override http request option.
         * @throws {RequiredError}
         */
        getDataSegmentIdentityMembershipV1(requestParameters: DataSegmentationApiGetDataSegmentIdentityMembershipV1Request, axiosOptions?: RawAxiosRequestConfig): AxiosPromise<Array<SegmentMembership>> {
            return localVarFp.getDataSegmentIdentityMembershipV1(requestParameters.identityId, requestParameters.xSailPointExperimental, axiosOptions).then((request) => request(axios, basePath));
        },
        /**
         * This API returns the segment specified by the given ID.
         * @summary Get segment by id
         * @param {DataSegmentationApiGetDataSegmentV1Request} requestParameters Request parameters.
         * @param {*} [axiosOptions] Override http request option.
         * @throws {RequiredError}
         */
        getDataSegmentV1(requestParameters: DataSegmentationApiGetDataSegmentV1Request, axiosOptions?: RawAxiosRequestConfig): AxiosPromise<DataSegment> {
            return localVarFp.getDataSegmentV1(requestParameters.segmentId, requestParameters.xSailPointExperimental, axiosOptions).then((request) => request(axios, basePath));
        },
        /**
         * This API returns whether or not segmentation is enabled for the identity.
         * @summary Is segmentation enabled by identity
         * @param {DataSegmentationApiGetDataSegmentationEnabledForUserV1Request} requestParameters Request parameters.
         * @param {*} [axiosOptions] Override http request option.
         * @throws {RequiredError}
         */
        getDataSegmentationEnabledForUserV1(requestParameters: DataSegmentationApiGetDataSegmentationEnabledForUserV1Request, axiosOptions?: RawAxiosRequestConfig): AxiosPromise<boolean> {
            return localVarFp.getDataSegmentationEnabledForUserV1(requestParameters.identityId, requestParameters.xSailPointExperimental, axiosOptions).then((request) => request(axios, basePath));
        },
        /**
         * This API returns the segment specified by the given ID.
         * @summary Get segments
         * @param {DataSegmentationApiListDataSegmentsV1Request} requestParameters Request parameters.
         * @param {*} [axiosOptions] Override http request option.
         * @throws {RequiredError}
         */
        listDataSegmentsV1(requestParameters: DataSegmentationApiListDataSegmentsV1Request = {}, axiosOptions?: RawAxiosRequestConfig): AxiosPromise<Array<DataSegment>> {
            return localVarFp.listDataSegmentsV1(requestParameters.enabled, requestParameters.unique, requestParameters.published, requestParameters.limit, requestParameters.offset, requestParameters.count, requestParameters.filters, requestParameters.xSailPointExperimental, axiosOptions).then((request) => request(axios, basePath));
        },
        /**
         * Use this API to update segment fields by using the [JSON Patch](https://tools.ietf.org/html/rfc6902) standard.
         * @summary Update segment
         * @param {DataSegmentationApiPatchDataSegmentV1Request} requestParameters Request parameters.
         * @param {*} [axiosOptions] Override http request option.
         * @throws {RequiredError}
         */
        patchDataSegmentV1(requestParameters: DataSegmentationApiPatchDataSegmentV1Request, axiosOptions?: RawAxiosRequestConfig): AxiosPromise<DataSegment> {
            return localVarFp.patchDataSegmentV1(requestParameters.segmentId, requestParameters.requestBody, requestParameters.xSailPointExperimental, axiosOptions).then((request) => request(axios, basePath));
        },
        /**
         * This will publish the segment so that it starts applying the segmentation to the desired users if enabled
         * @summary Publish segment by id
         * @param {DataSegmentationApiPublishDataSegmentV1Request} requestParameters Request parameters.
         * @param {*} [axiosOptions] Override http request option.
         * @throws {RequiredError}
         */
        publishDataSegmentV1(requestParameters: DataSegmentationApiPublishDataSegmentV1Request, axiosOptions?: RawAxiosRequestConfig): AxiosPromise<void> {
            return localVarFp.publishDataSegmentV1(requestParameters.segmentId, requestParameters.requestBody, requestParameters.publishAll, requestParameters.xSailPointExperimental, axiosOptions).then((request) => request(axios, basePath));
        },
    };
};

/**
 * Request parameters for createDataSegmentV1 operation in DataSegmentationApi.
 * @export
 * @interface DataSegmentationApiCreateDataSegmentV1Request
 */
export interface DataSegmentationApiCreateDataSegmentV1Request {
    /**
     * 
     * @type {DataSegment}
     * @memberof DataSegmentationApiCreateDataSegmentV1
     */
    readonly dataSegment: DataSegment

    /**
     * Use this header to enable this experimental API.
     * @type {string}
     * @memberof DataSegmentationApiCreateDataSegmentV1
     */
    readonly xSailPointExperimental?: string
}

/**
 * Request parameters for deleteDataSegmentV1 operation in DataSegmentationApi.
 * @export
 * @interface DataSegmentationApiDeleteDataSegmentV1Request
 */
export interface DataSegmentationApiDeleteDataSegmentV1Request {
    /**
     * The segment ID to delete.
     * @type {string}
     * @memberof DataSegmentationApiDeleteDataSegmentV1
     */
    readonly segmentId: string

    /**
     * This determines which version of the segment to delete
     * @type {boolean}
     * @memberof DataSegmentationApiDeleteDataSegmentV1
     */
    readonly published?: boolean

    /**
     * Use this header to enable this experimental API.
     * @type {string}
     * @memberof DataSegmentationApiDeleteDataSegmentV1
     */
    readonly xSailPointExperimental?: string
}

/**
 * Request parameters for getDataSegmentIdentityMembershipV1 operation in DataSegmentationApi.
 * @export
 * @interface DataSegmentationApiGetDataSegmentIdentityMembershipV1Request
 */
export interface DataSegmentationApiGetDataSegmentIdentityMembershipV1Request {
    /**
     * The identity ID to retrieve the segments they are in.
     * @type {string}
     * @memberof DataSegmentationApiGetDataSegmentIdentityMembershipV1
     */
    readonly identityId: string

    /**
     * Use this header to enable this experimental API.
     * @type {string}
     * @memberof DataSegmentationApiGetDataSegmentIdentityMembershipV1
     */
    readonly xSailPointExperimental?: string
}

/**
 * Request parameters for getDataSegmentV1 operation in DataSegmentationApi.
 * @export
 * @interface DataSegmentationApiGetDataSegmentV1Request
 */
export interface DataSegmentationApiGetDataSegmentV1Request {
    /**
     * The segment ID to retrieve.
     * @type {string}
     * @memberof DataSegmentationApiGetDataSegmentV1
     */
    readonly segmentId: string

    /**
     * Use this header to enable this experimental API.
     * @type {string}
     * @memberof DataSegmentationApiGetDataSegmentV1
     */
    readonly xSailPointExperimental?: string
}

/**
 * Request parameters for getDataSegmentationEnabledForUserV1 operation in DataSegmentationApi.
 * @export
 * @interface DataSegmentationApiGetDataSegmentationEnabledForUserV1Request
 */
export interface DataSegmentationApiGetDataSegmentationEnabledForUserV1Request {
    /**
     * The identity ID to retrieve if segmentation is enabled for the identity.
     * @type {string}
     * @memberof DataSegmentationApiGetDataSegmentationEnabledForUserV1
     */
    readonly identityId: string

    /**
     * Use this header to enable this experimental API.
     * @type {string}
     * @memberof DataSegmentationApiGetDataSegmentationEnabledForUserV1
     */
    readonly xSailPointExperimental?: string
}

/**
 * Request parameters for listDataSegmentsV1 operation in DataSegmentationApi.
 * @export
 * @interface DataSegmentationApiListDataSegmentsV1Request
 */
export interface DataSegmentationApiListDataSegmentsV1Request {
    /**
     * This boolean indicates whether the segment is currently active. Inactive segments have no effect.
     * @type {boolean}
     * @memberof DataSegmentationApiListDataSegmentsV1
     */
    readonly enabled?: boolean

    /**
     * This returns only one record if set to true and that would be the published record if exists.
     * @type {boolean}
     * @memberof DataSegmentationApiListDataSegmentsV1
     */
    readonly unique?: boolean

    /**
     * This boolean indicates whether the segment is being applied to the accounts. If unpublished its being actively modified until published
     * @type {boolean}
     * @memberof DataSegmentationApiListDataSegmentsV1
     */
    readonly published?: boolean

    /**
     * Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
     * @type {number}
     * @memberof DataSegmentationApiListDataSegmentsV1
     */
    readonly limit?: number

    /**
     * Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
     * @type {number}
     * @memberof DataSegmentationApiListDataSegmentsV1
     */
    readonly offset?: number

    /**
     * If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored.  Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used.  See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
     * @type {boolean}
     * @memberof DataSegmentationApiListDataSegmentsV1
     */
    readonly count?: boolean

    /**
     * Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results)  Filtering is supported for the following fields and operators:  **id**: *eq, in, sw*  **name**: *eq, in, sw*
     * @type {string}
     * @memberof DataSegmentationApiListDataSegmentsV1
     */
    readonly filters?: string

    /**
     * Use this header to enable this experimental API.
     * @type {string}
     * @memberof DataSegmentationApiListDataSegmentsV1
     */
    readonly xSailPointExperimental?: string
}

/**
 * Request parameters for patchDataSegmentV1 operation in DataSegmentationApi.
 * @export
 * @interface DataSegmentationApiPatchDataSegmentV1Request
 */
export interface DataSegmentationApiPatchDataSegmentV1Request {
    /**
     * The segment ID to modify.
     * @type {string}
     * @memberof DataSegmentationApiPatchDataSegmentV1
     */
    readonly segmentId: string

    /**
     * A list of segment update operations according to the [JSON Patch](https://tools.ietf.org/html/rfc6902) standard.  The following fields are patchable: * name * description * membership * memberFilter * memberSelection * scopes * enabled 
     * @type {Array<object>}
     * @memberof DataSegmentationApiPatchDataSegmentV1
     */
    readonly requestBody: Array<object>

    /**
     * Use this header to enable this experimental API.
     * @type {string}
     * @memberof DataSegmentationApiPatchDataSegmentV1
     */
    readonly xSailPointExperimental?: string
}

/**
 * Request parameters for publishDataSegmentV1 operation in DataSegmentationApi.
 * @export
 * @interface DataSegmentationApiPublishDataSegmentV1Request
 */
export interface DataSegmentationApiPublishDataSegmentV1Request {
    /**
     * The segmentId.
     * @type {string}
     * @memberof DataSegmentationApiPublishDataSegmentV1
     */
    readonly segmentId: string

    /**
     * A list of segment ids that you wish to publish
     * @type {Array<string>}
     * @memberof DataSegmentationApiPublishDataSegmentV1
     */
    readonly requestBody: Array<string>

    /**
     * This flag decides whether you want to publish all unpublished or a list of specific segment ids
     * @type {boolean}
     * @memberof DataSegmentationApiPublishDataSegmentV1
     */
    readonly publishAll?: boolean

    /**
     * Use this header to enable this experimental API.
     * @type {string}
     * @memberof DataSegmentationApiPublishDataSegmentV1
     */
    readonly xSailPointExperimental?: string
}

/**
 * DataSegmentationApi - object-oriented interface
 * @export
 * @class DataSegmentationApi
 * @extends {BaseAPI}
 */
export class DataSegmentationApi extends BaseAPI {
    /**
     * This API creates a segment.  >**Note:** Segment definitions may take time to propagate to all identities.
     * @summary Create segment
     * @param {DataSegmentationApiCreateDataSegmentV1Request} requestParameters Request parameters.
     * @param {*} [axiosOptions] Override http request option.
     * @throws {RequiredError}
     * @memberof DataSegmentationApi
     */
    public createDataSegmentV1(requestParameters: DataSegmentationApiCreateDataSegmentV1Request, axiosOptions?: RawAxiosRequestConfig) {
        return DataSegmentationApiFp(this.configuration).createDataSegmentV1(requestParameters.dataSegment, requestParameters.xSailPointExperimental, axiosOptions).then((request) => request(this.axios, this.basePath));
    }

    /**
     * This API deletes the segment specified by the given ID.
     * @summary Delete segment by id
     * @param {DataSegmentationApiDeleteDataSegmentV1Request} requestParameters Request parameters.
     * @param {*} [axiosOptions] Override http request option.
     * @throws {RequiredError}
     * @memberof DataSegmentationApi
     */
    public deleteDataSegmentV1(requestParameters: DataSegmentationApiDeleteDataSegmentV1Request, axiosOptions?: RawAxiosRequestConfig) {
        return DataSegmentationApiFp(this.configuration).deleteDataSegmentV1(requestParameters.segmentId, requestParameters.published, requestParameters.xSailPointExperimental, axiosOptions).then((request) => request(this.axios, this.basePath));
    }

    /**
     * This API returns the segment membership specified by the given identity ID.
     * @summary Get segmentmembership by identity id
     * @param {DataSegmentationApiGetDataSegmentIdentityMembershipV1Request} requestParameters Request parameters.
     * @param {*} [axiosOptions] Override http request option.
     * @throws {RequiredError}
     * @memberof DataSegmentationApi
     */
    public getDataSegmentIdentityMembershipV1(requestParameters: DataSegmentationApiGetDataSegmentIdentityMembershipV1Request, axiosOptions?: RawAxiosRequestConfig) {
        return DataSegmentationApiFp(this.configuration).getDataSegmentIdentityMembershipV1(requestParameters.identityId, requestParameters.xSailPointExperimental, axiosOptions).then((request) => request(this.axios, this.basePath));
    }

    /**
     * This API returns the segment specified by the given ID.
     * @summary Get segment by id
     * @param {DataSegmentationApiGetDataSegmentV1Request} requestParameters Request parameters.
     * @param {*} [axiosOptions] Override http request option.
     * @throws {RequiredError}
     * @memberof DataSegmentationApi
     */
    public getDataSegmentV1(requestParameters: DataSegmentationApiGetDataSegmentV1Request, axiosOptions?: RawAxiosRequestConfig) {
        return DataSegmentationApiFp(this.configuration).getDataSegmentV1(requestParameters.segmentId, requestParameters.xSailPointExperimental, axiosOptions).then((request) => request(this.axios, this.basePath));
    }

    /**
     * This API returns whether or not segmentation is enabled for the identity.
     * @summary Is segmentation enabled by identity
     * @param {DataSegmentationApiGetDataSegmentationEnabledForUserV1Request} requestParameters Request parameters.
     * @param {*} [axiosOptions] Override http request option.
     * @throws {RequiredError}
     * @memberof DataSegmentationApi
     */
    public getDataSegmentationEnabledForUserV1(requestParameters: DataSegmentationApiGetDataSegmentationEnabledForUserV1Request, axiosOptions?: RawAxiosRequestConfig) {
        return DataSegmentationApiFp(this.configuration).getDataSegmentationEnabledForUserV1(requestParameters.identityId, requestParameters.xSailPointExperimental, axiosOptions).then((request) => request(this.axios, this.basePath));
    }

    /**
     * This API returns the segment specified by the given ID.
     * @summary Get segments
     * @param {DataSegmentationApiListDataSegmentsV1Request} requestParameters Request parameters.
     * @param {*} [axiosOptions] Override http request option.
     * @throws {RequiredError}
     * @memberof DataSegmentationApi
     */
    public listDataSegmentsV1(requestParameters: DataSegmentationApiListDataSegmentsV1Request = {}, axiosOptions?: RawAxiosRequestConfig) {
        return DataSegmentationApiFp(this.configuration).listDataSegmentsV1(requestParameters.enabled, requestParameters.unique, requestParameters.published, requestParameters.limit, requestParameters.offset, requestParameters.count, requestParameters.filters, requestParameters.xSailPointExperimental, axiosOptions).then((request) => request(this.axios, this.basePath));
    }

    /**
     * Use this API to update segment fields by using the [JSON Patch](https://tools.ietf.org/html/rfc6902) standard.
     * @summary Update segment
     * @param {DataSegmentationApiPatchDataSegmentV1Request} requestParameters Request parameters.
     * @param {*} [axiosOptions] Override http request option.
     * @throws {RequiredError}
     * @memberof DataSegmentationApi
     */
    public patchDataSegmentV1(requestParameters: DataSegmentationApiPatchDataSegmentV1Request, axiosOptions?: RawAxiosRequestConfig) {
        return DataSegmentationApiFp(this.configuration).patchDataSegmentV1(requestParameters.segmentId, requestParameters.requestBody, requestParameters.xSailPointExperimental, axiosOptions).then((request) => request(this.axios, this.basePath));
    }

    /**
     * This will publish the segment so that it starts applying the segmentation to the desired users if enabled
     * @summary Publish segment by id
     * @param {DataSegmentationApiPublishDataSegmentV1Request} requestParameters Request parameters.
     * @param {*} [axiosOptions] Override http request option.
     * @throws {RequiredError}
     * @memberof DataSegmentationApi
     */
    public publishDataSegmentV1(requestParameters: DataSegmentationApiPublishDataSegmentV1Request, axiosOptions?: RawAxiosRequestConfig) {
        return DataSegmentationApiFp(this.configuration).publishDataSegmentV1(requestParameters.segmentId, requestParameters.requestBody, requestParameters.publishAll, requestParameters.xSailPointExperimental, axiosOptions).then((request) => request(this.axios, this.basePath));
    }
}