@lap v0.3
# Machine-readable API spec. Each @endpoint block is one API call.
@api Okta Admin Management
@base https://subdomain.okta.com
@version 5.1.0
@auth ApiKey Authorization in header | OAuth2
@endpoints 705
@hint download_for_search
@toc .well-known(6), api(654), attack-protection(4), device-access(4), integrations(9), oauth2(12), okta-personal-settings(3), privileged-access(5), security(1), webauthn-registration(7)

@group .well-known
@endpoint GET /.well-known/app-authenticator-configuration
@required {oauthClientId: str}
@returns(200)
@errors {400, 429}

@endpoint GET /.well-known/apple-app-site-association
@returns(200)
@errors {429}

@endpoint GET /.well-known/assetlinks.json
@returns(200) {items: map}
@errors {404, 429}

@endpoint GET /.well-known/okta-organization
@returns(200) {id: str, pipeline: str, _links: map{alternate: any, organization: any}}
@errors {429}

@endpoint GET /.well-known/ssf-configuration
@returns(200) {authorization_schemes: [map], configuration_endpoint: str(uri), default_subjects: str, delivery_methods_supported: [str(uri)], issuer: str, jwks_uri: str(uri), spec_version: str, verification_endpoint: str(uri)}
@errors {401, 403, 404, 429}

@endpoint GET /.well-known/webauthn
@returns(200)
@errors {404, 429}

@endgroup

@group api
@endpoint GET /api/v1/agentPools
@optional {limitPerPoolType: int=5, poolType: str, after: str}
@returns(200)
@errors {403, 429}

@endpoint GET /api/v1/agentPools/{poolId}/updates
@optional {scheduled: bool}
@returns(200)
@errors {403, 404, 429}

@endpoint POST /api/v1/agentPools/{poolId}/updates
@optional {agents: [map{id: str, isHidden: bool, isLatestGAedVersion: bool, lastConnection: str(date-time), name: str, operationalStatus: str, poolId: str, type: str, updateMessage: str, updateStatus: str, version: str, _links: map}], agentType: str(AD/IWA/LDAP/MFA/OPP/RUM/Radius), enabled: bool, id: str, name: str, notifyAdmin: bool, reason: str, schedule: map{cron: str, delay: int, duration: int, lastUpdated: str(date-time), timezone: str}, sortOrder: int, status: str(Cancelled/Failed/InProgress/Paused/Scheduled/Success), targetVersion: str, _links: map{self: any}}
@returns(201) {agents: [map], agentType: str, enabled: bool, id: str, name: str, notifyAdmin: bool, reason: str, schedule: map{cron: str, delay: int, duration: int, lastUpdated: str(date-time), timezone: str}, sortOrder: int, status: str, targetVersion: str, _links: map{self: any}}
@errors {400, 403, 404, 429}

@endpoint GET /api/v1/agentPools/{poolId}/updates/settings
@returns(200) {agentType: str, continueOnError: bool, latestVersion: str, minimalSupportedVersion: str, poolId: str, poolName: str, releaseChannel: str}
@errors {403, 404, 429}

@endpoint POST /api/v1/agentPools/{poolId}/updates/settings
@optional {agentType: str(AD/IWA/LDAP/MFA/OPP/RUM/Radius), continueOnError: bool, latestVersion: str, minimalSupportedVersion: str, poolId: str, poolName: str, releaseChannel: str(BETA/EA/GA/TEST)}
@returns(201) {agentType: str, continueOnError: bool, latestVersion: str, minimalSupportedVersion: str, poolId: str, poolName: str, releaseChannel: str}
@errors {400, 403, 404, 429}

@endpoint GET /api/v1/agentPools/{poolId}/updates/{updateId}
@returns(200) {agents: [map], agentType: str, enabled: bool, id: str, name: str, notifyAdmin: bool, reason: str, schedule: map{cron: str, delay: int, duration: int, lastUpdated: str(date-time), timezone: str}, sortOrder: int, status: str, targetVersion: str, _links: map{self: any}}
@errors {403, 404, 429}

@endpoint POST /api/v1/agentPools/{poolId}/updates/{updateId}
@optional {agents: [map{id: str, isHidden: bool, isLatestGAedVersion: bool, lastConnection: str(date-time), name: str, operationalStatus: str, poolId: str, type: str, updateMessage: str, updateStatus: str, version: str, _links: map}], agentType: str(AD/IWA/LDAP/MFA/OPP/RUM/Radius), enabled: bool, id: str, name: str, notifyAdmin: bool, reason: str, schedule: map{cron: str, delay: int, duration: int, lastUpdated: str(date-time), timezone: str}, sortOrder: int, status: str(Cancelled/Failed/InProgress/Paused/Scheduled/Success), targetVersion: str, _links: map{self: any}}
@returns(201) {agents: [map], agentType: str, enabled: bool, id: str, name: str, notifyAdmin: bool, reason: str, schedule: map{cron: str, delay: int, duration: int, lastUpdated: str(date-time), timezone: str}, sortOrder: int, status: str, targetVersion: str, _links: map{self: any}}
@errors {400, 403, 404, 429}

@endpoint DELETE /api/v1/agentPools/{poolId}/updates/{updateId}
@returns(204)
@errors {403, 404, 429}

@endpoint POST /api/v1/agentPools/{poolId}/updates/{updateId}/activate
@returns(201) {agents: [map], agentType: str, enabled: bool, id: str, name: str, notifyAdmin: bool, reason: str, schedule: map{cron: str, delay: int, duration: int, lastUpdated: str(date-time), timezone: str}, sortOrder: int, status: str, targetVersion: str, _links: map{self: any}}
@errors {403, 404, 429}

@endpoint POST /api/v1/agentPools/{poolId}/updates/{updateId}/deactivate
@returns(201) {agents: [map], agentType: str, enabled: bool, id: str, name: str, notifyAdmin: bool, reason: str, schedule: map{cron: str, delay: int, duration: int, lastUpdated: str(date-time), timezone: str}, sortOrder: int, status: str, targetVersion: str, _links: map{self: any}}
@errors {403, 404, 429}

@endpoint POST /api/v1/agentPools/{poolId}/updates/{updateId}/pause
@returns(201) {agents: [map], agentType: str, enabled: bool, id: str, name: str, notifyAdmin: bool, reason: str, schedule: map{cron: str, delay: int, duration: int, lastUpdated: str(date-time), timezone: str}, sortOrder: int, status: str, targetVersion: str, _links: map{self: any}}
@errors {403, 404, 429}

@endpoint POST /api/v1/agentPools/{poolId}/updates/{updateId}/resume
@returns(201) {agents: [map], agentType: str, enabled: bool, id: str, name: str, notifyAdmin: bool, reason: str, schedule: map{cron: str, delay: int, duration: int, lastUpdated: str(date-time), timezone: str}, sortOrder: int, status: str, targetVersion: str, _links: map{self: any}}
@errors {403, 404, 429}

@endpoint POST /api/v1/agentPools/{poolId}/updates/{updateId}/retry
@returns(201) {agents: [map], agentType: str, enabled: bool, id: str, name: str, notifyAdmin: bool, reason: str, schedule: map{cron: str, delay: int, duration: int, lastUpdated: str(date-time), timezone: str}, sortOrder: int, status: str, targetVersion: str, _links: map{self: any}}
@errors {403, 404, 429}

@endpoint POST /api/v1/agentPools/{poolId}/updates/{updateId}/stop
@returns(201) {agents: [map], agentType: str, enabled: bool, id: str, name: str, notifyAdmin: bool, reason: str, schedule: map{cron: str, delay: int, duration: int, lastUpdated: str(date-time), timezone: str}, sortOrder: int, status: str, targetVersion: str, _links: map{self: any}}
@errors {403, 404, 429}

@endpoint GET /api/v1/api-tokens
@returns(200)
@errors {403, 429}

@endpoint DELETE /api/v1/api-tokens/current
@returns(204)
@errors {403, 429}

@endpoint GET /api/v1/api-tokens/{apiTokenId}
@returns(200) {clientName: str, created: str(date-time), expiresAt: str(date-time), id: str, lastUpdated: str(date-time), name: str, network: map{connection: str, include: [str], exclude: [str]}, tokenWindow: str, userId: str, _link: map{self: any}}
@errors {403, 404, 429}

@endpoint PUT /api/v1/api-tokens/{apiTokenId}
@optional {clientName: str, created: str(date-time), name: str, network: map{connection: str, include: [str], exclude: [str]}, userId: str}
@returns(200) {clientName: str, created: str(date-time), expiresAt: str(date-time), id: str, lastUpdated: str(date-time), name: str, network: map{connection: str, include: [str], exclude: [str]}, tokenWindow: str, userId: str, _link: map{self: any}}
@errors {400, 403, 404, 429}

@endpoint DELETE /api/v1/api-tokens/{apiTokenId}
@returns(204)
@errors {403, 404, 429}

@endpoint GET /api/v1/apps
@optional {q: str, after: str, useOptimization: bool=false, limit: int(int32)=-1, filter: str, expand: str, includeNonDeleted: bool=false}
@returns(200)
@errors {403, 429}

@endpoint POST /api/v1/apps
@required {label: str, signOnMode: str(AUTO_LOGIN/BASIC_AUTH/BOOKMARK/BROWSER_PLUGIN/OPENID_CONNECT/SAML_1_1/SAML_2_0/SECURE_PASSWORD_STORE/WS_FEDERATION)}
@optional {activate: bool=true, OktaAccessGateway-Agent: str, accessibility: map{errorRedirectUrl: str, loginRedirectUrl: str, selfService: bool}, created: str(date-time), features: [str], id: str, lastUpdated: str(date-time), licensing: map{seatCount: int}, orn: str, profile: map, status: str(ACTIVE/DELETED/INACTIVE), universalLogout: map{identityStack: str, protocol: str, status: str, supportType: str}, visibility: map{appLinks: map, autoLaunch: bool, autoSubmitToolbar: bool, hide: map}, _embedded: map{user: map}, _links: any}
@returns(200) {accessibility: map{errorRedirectUrl: str, loginRedirectUrl: str, selfService: bool}, created: str(date-time), features: [str], id: str, label: str, lastUpdated: str(date-time), licensing: map{seatCount: int}, orn: str, profile: map, signOnMode: str, status: str, universalLogout: map{identityStack: str, protocol: str, status: str, supportType: str}, visibility: map{appLinks: map, autoLaunch: bool, autoSubmitToolbar: bool, hide: map{iOS: bool, web: bool}}, _embedded: map{user: map}, _links: any}
@errors {400, 403, 429}

@endpoint GET /api/v1/apps/{appId}
@optional {expand: str}
@returns(200) {accessibility: map{errorRedirectUrl: str, loginRedirectUrl: str, selfService: bool}, created: str(date-time), features: [str], id: str, label: str, lastUpdated: str(date-time), licensing: map{seatCount: int}, orn: str, profile: map, signOnMode: str, status: str, universalLogout: map{identityStack: str, protocol: str, status: str, supportType: str}, visibility: map{appLinks: map, autoLaunch: bool, autoSubmitToolbar: bool, hide: map{iOS: bool, web: bool}}, _embedded: map{user: map}, _links: any}
@errors {403, 404, 429}

@endpoint PUT /api/v1/apps/{appId}
@required {label: str, signOnMode: str(AUTO_LOGIN/BASIC_AUTH/BOOKMARK/BROWSER_PLUGIN/OPENID_CONNECT/SAML_1_1/SAML_2_0/SECURE_PASSWORD_STORE/WS_FEDERATION)}
@optional {accessibility: map{errorRedirectUrl: str, loginRedirectUrl: str, selfService: bool}, created: str(date-time), features: [str], id: str, lastUpdated: str(date-time), licensing: map{seatCount: int}, orn: str, profile: map, status: str(ACTIVE/DELETED/INACTIVE), universalLogout: map{identityStack: str, protocol: str, status: str, supportType: str}, visibility: map{appLinks: map, autoLaunch: bool, autoSubmitToolbar: bool, hide: map}, _embedded: map{user: map}, _links: any}
@returns(200) {accessibility: map{errorRedirectUrl: str, loginRedirectUrl: str, selfService: bool}, created: str(date-time), features: [str], id: str, label: str, lastUpdated: str(date-time), licensing: map{seatCount: int}, orn: str, profile: map, signOnMode: str, status: str, universalLogout: map{identityStack: str, protocol: str, status: str, supportType: str}, visibility: map{appLinks: map, autoLaunch: bool, autoSubmitToolbar: bool, hide: map{iOS: bool, web: bool}}, _embedded: map{user: map}, _links: any}
@errors {400, 403, 404, 429}

@endpoint DELETE /api/v1/apps/{appId}
@returns(204)
@errors {403, 404, 429}

@endpoint GET /api/v1/apps/{appId}/connections/default
@returns(200) {authScheme: str, baseUrl: str, profile: any, status: str, _links: any}
@errors {403, 404, 429}

@endpoint POST /api/v1/apps/{appId}/connections/default
@optional {activate: bool}
@returns(200) {authScheme: str, baseUrl: str, profile: any, status: str, _links: any}
@errors {400, 403, 404, 429}

@endpoint GET /api/v1/apps/{appId}/connections/default/jwks
@returns(200) {jwks: any}
@errors {401, 404, 429}

@endpoint POST /api/v1/apps/{appId}/connections/default/lifecycle/activate
@returns(204)
@errors {403, 404, 429}

@endpoint POST /api/v1/apps/{appId}/connections/default/lifecycle/deactivate
@returns(204)
@errors {403, 404, 429}

@endpoint GET /api/v1/apps/{appId}/credentials/csrs
@returns(200)
@errors {403, 404, 429}

@endpoint POST /api/v1/apps/{appId}/credentials/csrs
@optional {subject: map{commonName: str, countryName: str, localityName: str, organizationalUnitName: str, organizationName: str, stateOrProvinceName: str}, subjectAltNames: map{dnsNames: [str]}}
@returns(201) {created: str(date-time), csr: str, id: str, kty: str, _links: any}
@errors {400, 403, 404, 429}

@endpoint GET /api/v1/apps/{appId}/credentials/csrs/{csrId}
@returns(200) {created: str(date-time), csr: str, id: str, kty: str, _links: any}
@errors {403, 404, 429}

@endpoint DELETE /api/v1/apps/{appId}/credentials/csrs/{csrId}
@returns(204)
@errors {403, 404, 429}

@endpoint POST /api/v1/apps/{appId}/credentials/csrs/{csrId}/lifecycle/publish
@returns(201) {created: str(date-time), e: str, expiresAt: str(date-time), kid: str, kty: str, lastUpdated: str(date-time), n: str, use: str, x5c: [str], x5t#S256: str}
@errors {400, 403, 404, 429}

@endpoint GET /api/v1/apps/{appId}/credentials/jwks
@returns(200)
@errors {401, 403, 404, 429}

@endpoint POST /api/v1/apps/{appId}/credentials/jwks
@returns(201)
@errors {400, 401, 403, 429}

@endpoint GET /api/v1/apps/{appId}/credentials/jwks/{keyId}
@returns(200)
@errors {401, 403, 404, 429}

@endpoint DELETE /api/v1/apps/{appId}/credentials/jwks/{keyId}
@returns(204)
@errors {400, 401, 403, 404, 429}

@endpoint POST /api/v1/apps/{appId}/credentials/jwks/{keyId}/lifecycle/activate
@returns(200)
@errors {401, 403, 404, 429}

@endpoint POST /api/v1/apps/{appId}/credentials/jwks/{keyId}/lifecycle/deactivate
@returns(200)
@errors {400, 401, 403, 404, 429}

@endpoint GET /api/v1/apps/{appId}/credentials/keys
@returns(200)
@errors {403, 404, 429}

@endpoint POST /api/v1/apps/{appId}/credentials/keys/generate
@required {validityYears: int}
@returns(201) {created: str(date-time), e: str, expiresAt: str(date-time), kid: str, kty: str, lastUpdated: str(date-time), n: str, use: str, x5c: [str], x5t#S256: str}
@errors {400, 403, 404, 429}

@endpoint GET /api/v1/apps/{appId}/credentials/keys/{keyId}
@returns(200) {created: str(date-time), e: str, expiresAt: str(date-time), kid: str, kty: str, lastUpdated: str(date-time), n: str, use: str, x5c: [str], x5t#S256: str}
@errors {403, 404, 429}

@endpoint POST /api/v1/apps/{appId}/credentials/keys/{keyId}/clone
@required {targetAid: str}
@returns(201) {created: str(date-time), e: str, expiresAt: str(date-time), kid: str, kty: str, lastUpdated: str(date-time), n: str, use: str, x5c: [str], x5t#S256: str}
@errors {400, 403, 404, 429}

@endpoint GET /api/v1/apps/{appId}/credentials/secrets
@returns(200)
@errors {401, 403, 404, 429}

@endpoint POST /api/v1/apps/{appId}/credentials/secrets
@optional {client_secret: str, status: str(ACTIVE/INACTIVE)}
@returns(201) {client_secret: str, created: str, id: str, lastUpdated: str, secret_hash: str, status: str, _links: any}
@errors {400, 401, 403, 429}

@endpoint GET /api/v1/apps/{appId}/credentials/secrets/{secretId}
@returns(200) {client_secret: str, created: str, id: str, lastUpdated: str, secret_hash: str, status: str, _links: any}
@errors {401, 403, 404, 429}

@endpoint DELETE /api/v1/apps/{appId}/credentials/secrets/{secretId}
@returns(204)
@errors {400, 401, 403, 404, 429}

@endpoint POST /api/v1/apps/{appId}/credentials/secrets/{secretId}/lifecycle/activate
@returns(200) {client_secret: str, created: str, id: str, lastUpdated: str, secret_hash: str, status: str, _links: any}
@errors {401, 403, 404, 429}

@endpoint POST /api/v1/apps/{appId}/credentials/secrets/{secretId}/lifecycle/deactivate
@returns(200) {client_secret: str, created: str, id: str, lastUpdated: str, secret_hash: str, status: str, _links: any}
@errors {400, 401, 403, 404, 429}

@endpoint GET /api/v1/apps/{appId}/cwo/connections
@optional {after: str, limit: int(int32)=-1}
@returns(200)
@errors {401, 403, 404, 429}

@endpoint POST /api/v1/apps/{appId}/cwo/connections
@optional {created: str(date-time), id: str, lastUpdated: str(date-time), requestingAppInstanceId: str, resourceAppInstanceId: str, status: str(ACTIVE/INACTIVE)}
@returns(201) {created: str(date-time), id: str, lastUpdated: str(date-time), requestingAppInstanceId: str, resourceAppInstanceId: str, status: str}
@errors {400, 401, 403, 404, 429}

@endpoint GET /api/v1/apps/{appId}/cwo/connections/{connectionId}
@returns(200) {created: str(date-time), id: str, lastUpdated: str(date-time), requestingAppInstanceId: str, resourceAppInstanceId: str, status: str}
@errors {401, 403, 404, 429}

@endpoint PATCH /api/v1/apps/{appId}/cwo/connections/{connectionId}
@required {status: str(ACTIVE/INACTIVE)}
@returns(200) {created: str(date-time), id: str, lastUpdated: str(date-time), requestingAppInstanceId: str, resourceAppInstanceId: str, status: str}
@errors {400, 401, 403, 404, 429}

@endpoint DELETE /api/v1/apps/{appId}/cwo/connections/{connectionId}
@returns(204)
@errors {401, 403, 404, 429}

@endpoint GET /api/v1/apps/{appId}/features
@returns(200)
@errors {400, 403, 404, 429}

@endpoint GET /api/v1/apps/{appId}/features/{featureName}
@returns(200) {description: str, name: str, status: any, _links: any}
@errors {403, 404, 429}

@endpoint PUT /api/v1/apps/{appId}/features/{featureName}
@returns(200) {description: str, name: str, status: any, _links: any}
@errors {400, 403, 404, 429}

@endpoint GET /api/v1/apps/{appId}/federated-claims
@returns(200)
@errors {401, 403, 404, 429}

@endpoint POST /api/v1/apps/{appId}/federated-claims
@optional {expression: str, name: str}
@returns(201) {created: str, expression: str, id: str, lastUpdated: str, name: str}
@errors {400, 401, 403, 429}

@endpoint GET /api/v1/apps/{appId}/federated-claims/{claimId}
@returns(200) {expression: str, name: str}
@errors {401, 403, 404, 429}

@endpoint PUT /api/v1/apps/{appId}/federated-claims/{claimId}
@optional {created: str, expression: str, id: str, lastUpdated: str, name: str}
@returns(201) {created: str, expression: str, id: str, lastUpdated: str, name: str}
@errors {400, 401, 403, 429}

@endpoint DELETE /api/v1/apps/{appId}/federated-claims/{claimId}
@returns(204)
@errors {401, 403, 404, 429}

@endpoint GET /api/v1/apps/{appId}/grants
@optional {expand: str}
@returns(200)
@errors {403, 404, 429}

@endpoint POST /api/v1/apps/{appId}/grants
@required {issuer: str, scopeId: str}
@optional {clientId: str, created: str(date-time), createdBy: map{id: str, type: str}, id: str, lastUpdated: str(date-time), source: str(ADMIN/END_USER), status: str(ACTIVE/REVOKED), userId: str, _embedded: map{scope: map}, _links: any}
@returns(201) {clientId: str, created: str(date-time), createdBy: map{id: str, type: str}, id: str, issuer: str, lastUpdated: str(date-time), scopeId: str, source: str, status: str, userId: str, _embedded: map{scope: map{id: str}}, _links: any}
@errors {400, 403, 404, 429}

@endpoint GET /api/v1/apps/{appId}/grants/{grantId}
@optional {expand: str}
@returns(200) {clientId: str, created: str(date-time), createdBy: map{id: str, type: str}, id: str, issuer: str, lastUpdated: str(date-time), scopeId: str, source: str, status: str, userId: str, _embedded: map{scope: map{id: str}}, _links: any}
@errors {403, 404, 429}

@endpoint DELETE /api/v1/apps/{appId}/grants/{grantId}
@returns(204)
@errors {403, 404, 429}

@endpoint GET /api/v1/apps/{appId}/group-push/mappings
@optional {after: str, limit: int(int32)=100, lastUpdated: str, sourceGroupId: str, status: str}
@returns(200)
@errors {401, 403, 429}

@endpoint POST /api/v1/apps/{appId}/group-push/mappings
@required {sourceGroupId: str}
@optional {appConfig: map{type: str}, status: str(ACTIVE/INACTIVE)=ACTIVE, targetGroupId: str, targetGroupName: str}
@returns(201) {appConfig: map{type: str}, created: str(date-time), errorSummary: str, id: str, lastPush: str(date-time), lastUpdated: str(date-time), sourceGroupId: str, status: str, targetGroupId: str, _links: map}
@errors {400, 401, 403, 429}

@endpoint GET /api/v1/apps/{appId}/group-push/mappings/{mappingId}
@returns(200) {appConfig: map{type: str}, created: str(date-time), errorSummary: str, id: str, lastPush: str(date-time), lastUpdated: str(date-time), sourceGroupId: str, status: str, targetGroupId: str, _links: map}
@errors {401, 403, 404, 429}

@endpoint PATCH /api/v1/apps/{appId}/group-push/mappings/{mappingId}
@required {status: str(ACTIVE/INACTIVE)=ACTIVE}
@returns(200) {appConfig: map{type: str}, created: str(date-time), errorSummary: str, id: str, lastPush: str(date-time), lastUpdated: str(date-time), sourceGroupId: str, status: str, targetGroupId: str, _links: map}
@errors {400, 401, 403, 404, 429}

@endpoint DELETE /api/v1/apps/{appId}/group-push/mappings/{mappingId}
@required {deleteTargetGroup: bool=false}
@returns(204)
@errors {401, 403, 404, 429}

@endpoint GET /api/v1/apps/{appId}/groups
@optional {q: str, after: str, limit: int(int32)=20, expand: str}
@returns(200)
@errors {403, 404, 429}

@endpoint GET /api/v1/apps/{appId}/groups/{groupId}
@optional {expand: str}
@returns(200) {id: str, lastUpdated: any, priority: int, profile: map, _embedded: map, _links: any}
@errors {403, 404, 429}

@endpoint PUT /api/v1/apps/{appId}/groups/{groupId}
@optional {id: str, lastUpdated: any, priority: int, profile: map, _embedded: map, _links: any}
@returns(200) {id: str, lastUpdated: any, priority: int, profile: map, _embedded: map, _links: any}
@errors {400, 403, 404, 429}

@endpoint PATCH /api/v1/apps/{appId}/groups/{groupId}
@returns(200) {id: str, lastUpdated: any, priority: int, profile: map, _embedded: map, _links: any}
@errors {400, 403, 404, 429}

@endpoint DELETE /api/v1/apps/{appId}/groups/{groupId}
@returns(204)
@errors {403, 404, 429}

@endpoint POST /api/v1/apps/{appId}/lifecycle/activate
@returns(200)
@errors {403, 404, 429}

@endpoint POST /api/v1/apps/{appId}/lifecycle/deactivate
@returns(200)
@errors {403, 404, 429}

@endpoint POST /api/v1/apps/{appId}/logo
@returns(201)
@errors {400, 403, 404, 429}

@endpoint PUT /api/v1/apps/{appId}/policies/{policyId}
@returns(204)
@errors {403, 404, 429}

@endpoint GET /api/v1/apps/{appId}/sso/saml/metadata
@required {kid: str}
@returns(200)
@errors {403, 404, 429}

@endpoint GET /api/v1/apps/{appId}/tokens
@optional {expand: str, after: str, limit: int=20}
@returns(200)
@errors {403, 404, 429}

@endpoint DELETE /api/v1/apps/{appId}/tokens
@returns(204)
@errors {403, 404, 429}

@endpoint GET /api/v1/apps/{appId}/tokens/{tokenId}
@optional {expand: str}
@returns(200) {clientId: str, created: str(date-time), expiresAt: str(date-time), id: str, issuer: str, lastUpdated: str(date-time), scopes: [str], status: str, userId: str, _embedded: map{scopes: [map]}, _links: any}
@errors {403, 404, 429}

@endpoint DELETE /api/v1/apps/{appId}/tokens/{tokenId}
@returns(204)
@errors {403, 404, 429}

@endpoint GET /api/v1/apps/{appId}/users
@optional {after: str, limit: int(int32)=50, q: str, expand: str}
@returns(200)
@errors {403, 404, 429}

@endpoint POST /api/v1/apps/{appId}/users
@returns(200) {created: any, credentials: map{password: map{value: str(password)}, userName: str}, externalId: str, id: str, lastSync: str(date-time), lastUpdated: any, passwordChanged: str(date-time)?, profile: map, scope: str, status: str, statusChanged: str(date-time), syncState: str, _embedded: map, _links: map{app: any, group: any, user: any}}
@errors {400, 403, 404, 429}

@endpoint GET /api/v1/apps/{appId}/users/{userId}
@optional {expand: str}
@returns(200) {created: any, credentials: map{password: map{value: str(password)}, userName: str}, externalId: str, id: str, lastSync: str(date-time), lastUpdated: any, passwordChanged: str(date-time)?, profile: map, scope: str, status: str, statusChanged: str(date-time), syncState: str, _embedded: map, _links: map{app: any, group: any, user: any}}
@errors {403, 404, 429}

@endpoint POST /api/v1/apps/{appId}/users/{userId}
@returns(200) {created: any, credentials: map{password: map{value: str(password)}, userName: str}, externalId: str, id: str, lastSync: str(date-time), lastUpdated: any, passwordChanged: str(date-time)?, profile: map, scope: str, status: str, statusChanged: str(date-time), syncState: str, _embedded: map, _links: map{app: any, group: any, user: any}}
@errors {400, 403, 404, 429}

@endpoint DELETE /api/v1/apps/{appId}/users/{userId}
@optional {sendEmail: bool=false}
@returns(204)
@errors {403, 404, 429}

@endpoint POST /api/v1/apps/{appName}/{appId}/oauth2/callback
@optional {code: str, state: str}
@returns(204)
@errors {403, 404, 429}

@endpoint GET /api/v1/authenticators
@returns(200)
@errors {403, 429}

@endpoint POST /api/v1/authenticators
@optional {activate: bool=true, created: str(date-time), id: str, key: str(custom_app/duo/external_idp/google_otp/okta_email/okta_password/okta_verify/onprem_mfa/phone_number/security_key/security_question/smart_card_idp/symantec_vip/webauthn/yubikey_token/tac), lastUpdated: str(date-time), name: str, status: str(ACTIVE/INACTIVE), type: str(app/email/federated/password/phone/security_key/security_question/tac), _links: any}
@returns(200) {created: str(date-time), id: str, key: str, lastUpdated: str(date-time), name: str, status: str, type: str, _links: any}
@errors {400, 403, 429}

@endpoint GET /api/v1/authenticators/{authenticatorId}
@returns(200) {created: str(date-time), id: str, key: str, lastUpdated: str(date-time), name: str, status: str, type: str, _links: any}
@errors {403, 404, 429}

@endpoint PUT /api/v1/authenticators/{authenticatorId}
@optional {created: str(date-time), id: str, key: str(custom_app/duo/external_idp/google_otp/okta_email/okta_password/okta_verify/onprem_mfa/phone_number/security_key/security_question/smart_card_idp/symantec_vip/webauthn/yubikey_token/tac), lastUpdated: str(date-time), name: str, status: str(ACTIVE/INACTIVE), type: str(app/email/federated/password/phone/security_key/security_question/tac), _links: any}
@returns(200) {created: str(date-time), id: str, key: str, lastUpdated: str(date-time), name: str, status: str, type: str, _links: any}
@errors {400, 403, 404, 429}

@endpoint GET /api/v1/authenticators/{authenticatorId}/aaguids
@returns(200)
@errors {403, 404, 429}

@endpoint POST /api/v1/authenticators/{authenticatorId}/aaguids
@optional {aaguid: str, attestationRootCertificates: [map{x5c: str}], authenticatorCharacteristics: map{fipsCompliant: bool, hardwareProtected: bool, platformAttached: bool}}
@returns(200) {aaguid: str, attestationRootCertificates: [map], authenticatorCharacteristics: map{fipsCompliant: bool, hardwareProtected: bool, platformAttached: bool}, name: str, _links: map{self: any}}
@errors {403, 404, 429}

@endpoint GET /api/v1/authenticators/{authenticatorId}/aaguids/{aaguid}
@returns(200) {aaguid: str, attestationRootCertificates: [map], authenticatorCharacteristics: map{fipsCompliant: bool, hardwareProtected: bool, platformAttached: bool}, name: str, _links: map{self: any}}
@errors {403, 404, 429}

@endpoint PUT /api/v1/authenticators/{authenticatorId}/aaguids/{aaguid}
@optional {attestationRootCertificates: [map{x5c: str}], authenticatorCharacteristics: map{fipsCompliant: bool, hardwareProtected: bool, platformAttached: bool}, name: str}
@returns(200) {aaguid: str, attestationRootCertificates: [map], authenticatorCharacteristics: map{fipsCompliant: bool, hardwareProtected: bool, platformAttached: bool}, name: str, _links: map{self: any}}
@errors {403, 404, 429}

@endpoint PATCH /api/v1/authenticators/{authenticatorId}/aaguids/{aaguid}
@returns(200) {aaguid: str, attestationRootCertificates: [map], authenticatorCharacteristics: map{fipsCompliant: bool, hardwareProtected: bool, platformAttached: bool}, name: str, _links: map{self: any}}
@errors {403, 404, 429}

@endpoint DELETE /api/v1/authenticators/{authenticatorId}/aaguids/{aaguid}
@returns(204)
@errors {403, 404, 429}

@endpoint POST /api/v1/authenticators/{authenticatorId}/lifecycle/activate
@returns(200) {created: str(date-time), id: str, key: str, lastUpdated: str(date-time), name: str, status: str, type: str, _links: any}
@errors {403, 404, 429}

@endpoint POST /api/v1/authenticators/{authenticatorId}/lifecycle/deactivate
@returns(200) {created: str(date-time), id: str, key: str, lastUpdated: str(date-time), name: str, status: str, type: str, _links: any}
@errors {403, 404, 429}

@endpoint GET /api/v1/authenticators/{authenticatorId}/methods
@returns(200)
@errors {403, 404, 429}

@endpoint GET /api/v1/authenticators/{authenticatorId}/methods/{methodType}
@returns(200) {status: str, type: str, _links: any}
@errors {403, 404, 429}

@endpoint PUT /api/v1/authenticators/{authenticatorId}/methods/{methodType}
@optional {status: str(ACTIVE/INACTIVE), type: str(cert/duo/email/idp/otp/password/push/security_question/signed_nonce/sms/totp/voice/webauthn/tac), _links: any}
@returns(200) {status: str, type: str, _links: any}
@errors {400, 403, 404, 429}

@endpoint POST /api/v1/authenticators/{authenticatorId}/methods/{methodType}/lifecycle/activate
@returns(200) {status: str, type: str, _links: any}
@errors {403, 404, 429}

@endpoint POST /api/v1/authenticators/{authenticatorId}/methods/{methodType}/lifecycle/deactivate
@returns(200) {status: str, type: str, _links: any}
@errors {403, 404, 429}

@endpoint GET /api/v1/authorizationServers
@optional {q: str, limit: int(int32)=200, after: str}
@returns(200)
@errors {403, 429}

@endpoint POST /api/v1/authorizationServers
@optional {accessTokenEncryptedResponseAlgorithm: str(RSA-OAEP-256/RSA-OAEP-384/RSA-OAEP-512), audiences: [str], created: str(date-time), credentials: map{signing: map}, description: str, id: str, issuer: str, issuerMode: str, jwks: map{keys: [map]}, jwks_uri: str, lastUpdated: str(date-time), name: str, status: str(ACTIVE/INACTIVE), _links: any}
@returns(201) {accessTokenEncryptedResponseAlgorithm: str, audiences: [str], created: str(date-time), credentials: map{signing: map{kid: str, lastRotated: str(date-time), nextRotation: str(date-time), rotationMode: str, use: str}}, description: str, id: str, issuer: str, issuerMode: str, jwks: map{keys: [map]}, jwks_uri: str, lastUpdated: str(date-time), name: str, status: str, _links: any}
@errors {400, 403, 429}

@endpoint GET /api/v1/authorizationServers/{authServerId}
@returns(200) {accessTokenEncryptedResponseAlgorithm: str, audiences: [str], created: str(date-time), credentials: map{signing: map{kid: str, lastRotated: str(date-time), nextRotation: str(date-time), rotationMode: str, use: str}}, description: str, id: str, issuer: str, issuerMode: str, jwks: map{keys: [map]}, jwks_uri: str, lastUpdated: str(date-time), name: str, status: str, _links: any}
@errors {403, 404, 429}

@endpoint PUT /api/v1/authorizationServers/{authServerId}
@optional {accessTokenEncryptedResponseAlgorithm: str(RSA-OAEP-256/RSA-OAEP-384/RSA-OAEP-512), audiences: [str], created: str(date-time), credentials: map{signing: map}, description: str, id: str, issuer: str, issuerMode: str, jwks: map{keys: [map]}, jwks_uri: str, lastUpdated: str(date-time), name: str, status: str(ACTIVE/INACTIVE), _links: any}
@returns(200) {accessTokenEncryptedResponseAlgorithm: str, audiences: [str], created: str(date-time), credentials: map{signing: map{kid: str, lastRotated: str(date-time), nextRotation: str(date-time), rotationMode: str, use: str}}, description: str, id: str, issuer: str, issuerMode: str, jwks: map{keys: [map]}, jwks_uri: str, lastUpdated: str(date-time), name: str, status: str, _links: any}
@errors {400, 403, 404, 429}

@endpoint DELETE /api/v1/authorizationServers/{authServerId}
@returns(204)
@errors {403, 404, 429}

@endpoint GET /api/v1/authorizationServers/{authServerId}/associatedServers
@optional {trusted: bool, q: str, limit: int(int32)=200, after: str}
@returns(200)
@errors {403, 404, 429}

@endpoint POST /api/v1/authorizationServers/{authServerId}/associatedServers
@optional {trusted: [str]}
@returns(200)
@errors {400, 403, 404, 429}

@endpoint DELETE /api/v1/authorizationServers/{authServerId}/associatedServers/{associatedServerId}
@returns(204)
@errors {403, 404, 429}

@endpoint GET /api/v1/authorizationServers/{authServerId}/claims
@returns(200)
@errors {403, 404, 429}

@endpoint POST /api/v1/authorizationServers/{authServerId}/claims
@optional {alwaysIncludeInToken: bool, claimType: str(IDENTITY/RESOURCE), conditions: map{scopes: [str]}, group_filter_type: str(CONTAINS/EQUALS/REGEX/STARTS_WITH), id: str, name: str, status: str(ACTIVE/INACTIVE), system: bool, value: str, valueType: str(EXPRESSION/GROUPS/SYSTEM), _links: map{self: any}}
@returns(201) {alwaysIncludeInToken: bool, claimType: str, conditions: map{scopes: [str]}, group_filter_type: str, id: str, name: str, status: str, system: bool, value: str, valueType: str, _links: map{self: any}}
@errors {400, 403, 404, 429}

@endpoint GET /api/v1/authorizationServers/{authServerId}/claims/{claimId}
@returns(200) {alwaysIncludeInToken: bool, claimType: str, conditions: map{scopes: [str]}, group_filter_type: str, id: str, name: str, status: str, system: bool, value: str, valueType: str, _links: map{self: any}}
@errors {403, 404, 429}

@endpoint PUT /api/v1/authorizationServers/{authServerId}/claims/{claimId}
@optional {alwaysIncludeInToken: bool, claimType: str(IDENTITY/RESOURCE), conditions: map{scopes: [str]}, group_filter_type: str(CONTAINS/EQUALS/REGEX/STARTS_WITH), id: str, name: str, status: str(ACTIVE/INACTIVE), system: bool, value: str, valueType: str(EXPRESSION/GROUPS/SYSTEM), _links: map{self: any}}
@returns(200) {alwaysIncludeInToken: bool, claimType: str, conditions: map{scopes: [str]}, group_filter_type: str, id: str, name: str, status: str, system: bool, value: str, valueType: str, _links: map{self: any}}
@errors {400, 403, 404, 429}

@endpoint DELETE /api/v1/authorizationServers/{authServerId}/claims/{claimId}
@returns(204)
@errors {403, 404, 429}

@endpoint GET /api/v1/authorizationServers/{authServerId}/clients
@returns(200)
@errors {403, 404, 429}

@endpoint GET /api/v1/authorizationServers/{authServerId}/clients/{clientId}/tokens
@optional {expand: str, after: str, limit: int(int32)=-1}
@returns(200)
@errors {403, 404, 429}

@endpoint DELETE /api/v1/authorizationServers/{authServerId}/clients/{clientId}/tokens
@returns(204)
@errors {403, 404, 429}

@endpoint GET /api/v1/authorizationServers/{authServerId}/clients/{clientId}/tokens/{tokenId}
@optional {expand: str}
@returns(200) {clientId: str, created: str(date-time), expiresAt: str(date-time), id: str, issuer: str, lastUpdated: str(date-time), scopes: [str], status: str, userId: str, _embedded: map{scopes: [map]}, _links: any}
@errors {403, 404, 429}

@endpoint DELETE /api/v1/authorizationServers/{authServerId}/clients/{clientId}/tokens/{tokenId}
@returns(204)
@errors {403, 404, 429}

@endpoint GET /api/v1/authorizationServers/{authServerId}/credentials/keys
@returns(200)
@errors {403, 404, 429}

@endpoint GET /api/v1/authorizationServers/{authServerId}/credentials/keys/{keyId}
@returns(200) {alg: str, e: str, kid: str, kty: str, n: str, status: str, use: str, _links: map{self: any}}
@errors {403, 404, 429}

@endpoint POST /api/v1/authorizationServers/{authServerId}/credentials/lifecycle/keyRotate
@optional {use: str}
@returns(200)
@errors {400, 403, 404, 429}

@endpoint POST /api/v1/authorizationServers/{authServerId}/lifecycle/activate
@returns(204)
@errors {403, 404, 429}

@endpoint POST /api/v1/authorizationServers/{authServerId}/lifecycle/deactivate
@returns(204)
@errors {403, 404, 429}

@endpoint GET /api/v1/authorizationServers/{authServerId}/policies
@returns(200)
@errors {403, 404, 429}

@endpoint POST /api/v1/authorizationServers/{authServerId}/policies
@returns(201)
@errors {400, 403, 404, 429}

@endpoint GET /api/v1/authorizationServers/{authServerId}/policies/{policyId}
@returns(200)
@errors {403, 404, 429}

@endpoint PUT /api/v1/authorizationServers/{authServerId}/policies/{policyId}
@returns(200)
@errors {400, 403, 404, 429}

@endpoint DELETE /api/v1/authorizationServers/{authServerId}/policies/{policyId}
@returns(204)
@errors {403, 404, 429}

@endpoint POST /api/v1/authorizationServers/{authServerId}/policies/{policyId}/lifecycle/activate
@returns(204)
@errors {403, 404, 429}

@endpoint POST /api/v1/authorizationServers/{authServerId}/policies/{policyId}/lifecycle/deactivate
@returns(204)
@errors {403, 404, 429}

@endpoint GET /api/v1/authorizationServers/{authServerId}/policies/{policyId}/rules
@returns(200)
@errors {403, 404, 429}

@endpoint POST /api/v1/authorizationServers/{authServerId}/policies/{policyId}/rules
@returns(201) {actions: any, conditions: map{grantTypes: map{include: [str]}, people: map{groups: map{include: [str]}, users: map{include: [str]}}, scopes: map{include: [str]}}, created: str(date-time), id: str, lastUpdated: str(date-time), name: str, priority: int, status: str, system: bool, type: str, _links: any}
@errors {400, 403, 404, 429}

@endpoint GET /api/v1/authorizationServers/{authServerId}/policies/{policyId}/rules/{ruleId}
@returns(200) {actions: any, conditions: map{grantTypes: map{include: [str]}, people: map{groups: map{include: [str]}, users: map{include: [str]}}, scopes: map{include: [str]}}, created: str(date-time), id: str, lastUpdated: str(date-time), name: str, priority: int, status: str, system: bool, type: str, _links: any}
@errors {403, 404, 429}

@endpoint PUT /api/v1/authorizationServers/{authServerId}/policies/{policyId}/rules/{ruleId}
@returns(200) {actions: any, conditions: map{grantTypes: map{include: [str]}, people: map{groups: map{include: [str]}, users: map{include: [str]}}, scopes: map{include: [str]}}, created: str(date-time), id: str, lastUpdated: str(date-time), name: str, priority: int, status: str, system: bool, type: str, _links: any}
@errors {400, 403, 404, 429}

@endpoint DELETE /api/v1/authorizationServers/{authServerId}/policies/{policyId}/rules/{ruleId}
@returns(204)
@errors {403, 404, 429}

@endpoint POST /api/v1/authorizationServers/{authServerId}/policies/{policyId}/rules/{ruleId}/lifecycle/activate
@returns(204)
@errors {403, 404, 429}

@endpoint POST /api/v1/authorizationServers/{authServerId}/policies/{policyId}/rules/{ruleId}/lifecycle/deactivate
@returns(204)
@errors {403, 404, 429}

@endpoint GET /api/v1/authorizationServers/{authServerId}/resourceservercredentials/keys
@returns(200)
@errors {401, 403, 404, 429}

@endpoint POST /api/v1/authorizationServers/{authServerId}/resourceservercredentials/keys
@optional {e: str, kid: str, kty: str, n: str, status: str(ACTIVE/INACTIVE), use: str}
@returns(201) {created: str, e: str, id: str, kid: str?, kty: str, lastUpdated: str, n: str, status: str, use: str, _links: any}
@errors {400, 401, 403, 429}

@endpoint GET /api/v1/authorizationServers/{authServerId}/resourceservercredentials/keys/{keyId}
@returns(200) {created: str, e: str, id: str, kid: str?, kty: str, lastUpdated: str, n: str, status: str, use: str, _links: any}
@errors {401, 403, 404, 429}

@endpoint DELETE /api/v1/authorizationServers/{authServerId}/resourceservercredentials/keys/{keyId}
@returns(204)
@errors {400, 401, 403, 404, 429}

@endpoint POST /api/v1/authorizationServers/{authServerId}/resourceservercredentials/keys/{keyId}/lifecycle/activate
@returns(200) {created: str, e: str, id: str, kid: str?, kty: str, lastUpdated: str, n: str, status: str, use: str, _links: any}
@errors {401, 403, 404, 429}

@endpoint POST /api/v1/authorizationServers/{authServerId}/resourceservercredentials/keys/{keyId}/lifecycle/deactivate
@returns(200) {created: str, e: str, id: str, kid: str?, kty: str, lastUpdated: str, n: str, status: str, use: str, _links: any}
@errors {400, 401, 403, 404, 429}

@endpoint GET /api/v1/authorizationServers/{authServerId}/scopes
@optional {q: str, filter: str, after: str, limit: int}
@returns(200)
@errors {403, 404, 429}

@endpoint POST /api/v1/authorizationServers/{authServerId}/scopes
@required {name: str}
@optional {consent: str(FLEXIBLE/IMPLICIT/REQUIRED)=IMPLICIT, default: bool=false, description: str, displayName: str, id: str, metadataPublish: str(ALL_CLIENTS/NO_CLIENTS)=NO_CLIENTS, optional: bool=false, system: bool=false, _links: map{self: any}}
@returns(201) {consent: str, default: bool, description: str, displayName: str, id: str, metadataPublish: str, name: str, optional: bool, system: bool, _links: map{self: any}}
@errors {400, 403, 404, 429}

@endpoint GET /api/v1/authorizationServers/{authServerId}/scopes/{scopeId}
@returns(200) {consent: str, default: bool, description: str, displayName: str, id: str, metadataPublish: str, name: str, optional: bool, system: bool, _links: map{self: any}}
@errors {403, 404, 429}

@endpoint PUT /api/v1/authorizationServers/{authServerId}/scopes/{scopeId}
@required {name: str}
@optional {consent: str(FLEXIBLE/IMPLICIT/REQUIRED)=IMPLICIT, default: bool=false, description: str, displayName: str, id: str, metadataPublish: str(ALL_CLIENTS/NO_CLIENTS)=NO_CLIENTS, optional: bool=false, system: bool=false, _links: map{self: any}}
@returns(200) {consent: str, default: bool, description: str, displayName: str, id: str, metadataPublish: str, name: str, optional: bool, system: bool, _links: map{self: any}}
@errors {400, 403, 404, 429}

@endpoint DELETE /api/v1/authorizationServers/{authServerId}/scopes/{scopeId}
@returns(204)
@errors {403, 404, 429}

@endpoint GET /api/v1/behaviors
@returns(200)
@errors {403, 429}

@endpoint POST /api/v1/behaviors
@required {name: str, type: str(ANOMALOUS_DEVICE/ANOMALOUS_IP/ANOMALOUS_LOCATION/VELOCITY)}
@optional {created: str, id: str, lastUpdated: str, status: str(ACTIVE/INACTIVE), _link: map{self: any}}
@returns(200) {created: str, id: str, lastUpdated: str, name: str, status: str, type: str, _link: map{self: any}}
@errors {400, 403, 429}

@endpoint GET /api/v1/behaviors/{behaviorId}
@returns(200) {created: str, id: str, lastUpdated: str, name: str, status: str, type: str, _link: map{self: any}}
@errors {403, 404, 429}

@endpoint PUT /api/v1/behaviors/{behaviorId}
@required {name: str, type: str(ANOMALOUS_DEVICE/ANOMALOUS_IP/ANOMALOUS_LOCATION/VELOCITY)}
@optional {created: str, id: str, lastUpdated: str, status: str(ACTIVE/INACTIVE), _link: map{self: any}}
@returns(200) {created: str, id: str, lastUpdated: str, name: str, status: str, type: str, _link: map{self: any}}
@errors {400, 403, 404, 429}

@endpoint DELETE /api/v1/behaviors/{behaviorId}
@returns(204)
@errors {403, 404, 429}

@endpoint POST /api/v1/behaviors/{behaviorId}/lifecycle/activate
@returns(200) {created: str, id: str, lastUpdated: str, name: str, status: str, type: str, _link: map{self: any}}
@errors {403, 404, 429}

@endpoint POST /api/v1/behaviors/{behaviorId}/lifecycle/deactivate
@returns(200) {created: str, id: str, lastUpdated: str, name: str, status: str, type: str, _link: map{self: any}}
@errors {403, 404, 429}

@endpoint GET /api/v1/brands
@optional {expand: [str], after: str, limit: int=20, q: str}
@returns(200)
@errors {403, 429}

@endpoint POST /api/v1/brands
@required {name: str}
@returns(201) {agreeToCustomPrivacyPolicy: bool, customPrivacyPolicyUrl: str, defaultApp: map{appInstanceId: str, appLinkName: str, classicApplicationUri: str}, emailDomainId: str, id: str, isDefault: bool, locale: str, name: str, removePoweredByOkta: bool}
@errors {400, 403, 409, 429}

@endpoint GET /api/v1/brands/{brandId}
@optional {expand: [str]}
@returns(200) {_embedded: map{themes: [map], domains: [map], emailDomain: map{dnsValidationRecords: [map], domain: str, id: str, validationStatus: str, validationSubdomain: str}}, _links: any}
@errors {403, 404, 429}

@endpoint PUT /api/v1/brands/{brandId}
@required {name: str}
@optional {agreeToCustomPrivacyPolicy: bool, customPrivacyPolicyUrl: str, defaultApp: map{appInstanceId: str, appLinkName: str, classicApplicationUri: str}, emailDomainId: str, locale: str, removePoweredByOkta: bool=false}
@returns(200) {agreeToCustomPrivacyPolicy: bool, customPrivacyPolicyUrl: str, defaultApp: map{appInstanceId: str, appLinkName: str, classicApplicationUri: str}, emailDomainId: str, id: str, isDefault: bool, locale: str, name: str, removePoweredByOkta: bool}
@errors {400, 403, 404, 429}

@endpoint DELETE /api/v1/brands/{brandId}
@returns(204)
@errors {403, 404, 409, 429}

@endpoint GET /api/v1/brands/{brandId}/domains
@returns(200)
@errors {403, 404, 429}

@endpoint GET /api/v1/brands/{brandId}/pages/error
@returns(200) {_embedded: map{default: map{pageContent: str}, customized: map{pageContent: str}, customizedUrl: str(uri), preview: map{pageContent: str}, previewUrl: str(uri)}, _links: any}
@errors {403, 404, 429}

@endpoint GET /api/v1/brands/{brandId}/pages/error/customized
@returns(200)
@errors {403, 404, 429}

@endpoint PUT /api/v1/brands/{brandId}/pages/error/customized
@returns(200)
@errors {400, 403, 404, 429}

@endpoint DELETE /api/v1/brands/{brandId}/pages/error/customized
@returns(204)
@errors {403, 404, 429}

@endpoint GET /api/v1/brands/{brandId}/pages/error/default
@returns(200)
@errors {403, 404, 429}

@endpoint GET /api/v1/brands/{brandId}/pages/error/preview
@returns(200)
@errors {403, 404, 429}

@endpoint PUT /api/v1/brands/{brandId}/pages/error/preview
@returns(200)
@errors {400, 403, 404, 429}

@endpoint DELETE /api/v1/brands/{brandId}/pages/error/preview
@returns(204)
@errors {403, 404, 429}

@endpoint GET /api/v1/brands/{brandId}/pages/sign-in
@returns(200) {_embedded: map{default: map{pageContent: str}, customized: map{pageContent: str}, customizedUrl: str(uri), preview: map{pageContent: str}, previewUrl: str(uri)}, _links: any}
@errors {403, 404, 429}

@endpoint GET /api/v1/brands/{brandId}/pages/sign-in/customized
@returns(200)
@errors {403, 404, 429}

@endpoint PUT /api/v1/brands/{brandId}/pages/sign-in/customized
@returns(200)
@errors {400, 403, 404, 429}

@endpoint DELETE /api/v1/brands/{brandId}/pages/sign-in/customized
@returns(204)
@errors {403, 404, 429}

@endpoint GET /api/v1/brands/{brandId}/pages/sign-in/default
@returns(200)
@errors {403, 404, 429}

@endpoint GET /api/v1/brands/{brandId}/pages/sign-in/preview
@returns(200)
@errors {403, 404, 429}

@endpoint PUT /api/v1/brands/{brandId}/pages/sign-in/preview
@returns(200)
@errors {400, 403, 404, 429}

@endpoint DELETE /api/v1/brands/{brandId}/pages/sign-in/preview
@returns(204)
@errors {403, 404, 429}

@endpoint GET /api/v1/brands/{brandId}/pages/sign-in/widget-versions
@returns(200)
@errors {403, 404, 429}

@endpoint GET /api/v1/brands/{brandId}/pages/sign-out/customized
@returns(200) {type: str, url: str}
@errors {403, 404, 429}

@endpoint PUT /api/v1/brands/{brandId}/pages/sign-out/customized
@required {type: str(EXTERNALLY_HOSTED/OKTA_DEFAULT)}
@optional {url: str}
@returns(200) {type: str, url: str}
@errors {400, 403, 404, 429}

@endpoint GET /api/v1/brands/{brandId}/templates/email
@optional {after: str, limit: int=20, expand: [str]}
@returns(200)
@errors {403, 404, 429}

@endpoint GET /api/v1/brands/{brandId}/templates/email/{templateName}
@optional {expand: [str]}
@returns(200) {name: str, _embedded: map{settings: map{recipients: str, _links: any}, customizationCount: int}, _links: any}
@errors {403, 404, 429}

@endpoint GET /api/v1/brands/{brandId}/templates/email/{templateName}/customizations
@optional {after: str, limit: int=20}
@returns(200)
@errors {403, 404, 429}

@endpoint POST /api/v1/brands/{brandId}/templates/email/{templateName}/customizations
@returns(201)
@errors {400, 403, 404, 409, 429}

@endpoint DELETE /api/v1/brands/{brandId}/templates/email/{templateName}/customizations
@returns(204)
@errors {403, 404, 429}

@endpoint GET /api/v1/brands/{brandId}/templates/email/{templateName}/customizations/{customizationId}
@returns(200)
@errors {403, 404, 429}

@endpoint PUT /api/v1/brands/{brandId}/templates/email/{templateName}/customizations/{customizationId}
@returns(200)
@errors {400, 403, 404, 409, 429}

@endpoint DELETE /api/v1/brands/{brandId}/templates/email/{templateName}/customizations/{customizationId}
@returns(204)
@errors {403, 404, 409, 429}

@endpoint GET /api/v1/brands/{brandId}/templates/email/{templateName}/customizations/{customizationId}/preview
@returns(200) {body: str, subject: str, _links: any}
@errors {403, 404, 429}

@endpoint GET /api/v1/brands/{brandId}/templates/email/{templateName}/default-content
@optional {language: str}
@returns(200)
@errors {403, 404, 429}

@endpoint GET /api/v1/brands/{brandId}/templates/email/{templateName}/default-content/preview
@optional {language: str}
@returns(200) {body: str, subject: str, _links: any}
@errors {403, 404, 429}

@endpoint GET /api/v1/brands/{brandId}/templates/email/{templateName}/settings
@returns(200) {recipients: str, _links: any}
@errors {403, 404, 429}

@endpoint PUT /api/v1/brands/{brandId}/templates/email/{templateName}/settings
@required {recipients: str(ALL_USERS/ADMINS_ONLY/NO_USERS)}
@returns(200) {recipients: str}
@errors {400, 403, 404, 409, 422, 429}

@endpoint POST /api/v1/brands/{brandId}/templates/email/{templateName}/test
@optional {language: str}
@returns(204)
@errors {403, 404, 429}

@endpoint GET /api/v1/brands/{brandId}/themes
@returns(200)
@errors {403, 404, 429}

@endpoint GET /api/v1/brands/{brandId}/themes/{themeId}
@returns(200) {backgroundImage: str, emailTemplateTouchPointVariant: str, endUserDashboardTouchPointVariant: str, errorPageTouchPointVariant: str, favicon: str, id: str, loadingPageTouchPointVariant: str, logo: str, primaryColorContrastHex: str, primaryColorHex: str, secondaryColorContrastHex: str, secondaryColorHex: str, signInPageTouchPointVariant: str, _links: map{self: any}}
@errors {403, 404, 429}

@endpoint PUT /api/v1/brands/{brandId}/themes/{themeId}
@required {emailTemplateTouchPointVariant: str(FULL_THEME/OKTA_DEFAULT)=OKTA_DEFAULT, endUserDashboardTouchPointVariant: str(FULL_THEME/LOGO_ON_FULL_WHITE_BACKGROUND/OKTA_DEFAULT/WHITE_LOGO_BACKGROUND)=OKTA_DEFAULT, errorPageTouchPointVariant: str(BACKGROUND_IMAGE/BACKGROUND_SECONDARY_COLOR/OKTA_DEFAULT)=OKTA_DEFAULT, primaryColorHex: str=null, secondaryColorHex: str=null, signInPageTouchPointVariant: str(BACKGROUND_IMAGE/BACKGROUND_SECONDARY_COLOR/OKTA_DEFAULT)}
@optional {loadingPageTouchPointVariant: str(NONE/OKTA_DEFAULT)=OKTA_DEFAULT, primaryColorContrastHex: str=null, secondaryColorContrastHex: str=null, _links: map{self: any}}
@returns(200) {backgroundImage: str, emailTemplateTouchPointVariant: str, endUserDashboardTouchPointVariant: str, errorPageTouchPointVariant: str, favicon: str, id: str, loadingPageTouchPointVariant: str, logo: str, primaryColorContrastHex: str, primaryColorHex: str, secondaryColorContrastHex: str, secondaryColorHex: str, signInPageTouchPointVariant: str, _links: map{self: any}}
@errors {400, 403, 404, 429}

@endpoint POST /api/v1/brands/{brandId}/themes/{themeId}/background-image
@returns(201) {url: str}
@errors {400, 403, 404, 429}

@endpoint DELETE /api/v1/brands/{brandId}/themes/{themeId}/background-image
@returns(204)
@errors {403, 404, 429}

@endpoint POST /api/v1/brands/{brandId}/themes/{themeId}/favicon
@returns(201) {url: str}
@errors {400, 403, 404, 429}

@endpoint DELETE /api/v1/brands/{brandId}/themes/{themeId}/favicon
@returns(204)
@errors {403, 404, 429}

@endpoint POST /api/v1/brands/{brandId}/themes/{themeId}/logo
@returns(200) {url: str}
@errors {400, 403, 404, 429}

@endpoint DELETE /api/v1/brands/{brandId}/themes/{themeId}/logo
@returns(204)
@errors {403, 404, 429}

@endpoint GET /api/v1/brands/{brandId}/well-known-uris
@returns(200) {_embedded: map{apple-app-site-association: map{customized: map{representation: map, _links: any}}, assetlinks.json: map{customized: map{representation: [any], _links: any}}, webauthn: map{customized: map{representation: map, _links: any}}}, _links: any}
@errors {403, 404, 429}

@endpoint GET /api/v1/brands/{brandId}/well-known-uris/{path}
@returns(200) {representation: map, _links: any}
@errors {400, 403, 404, 429}

@endpoint GET /api/v1/brands/{brandId}/well-known-uris/{path}/customized
@returns(200) {representation: map, _links: any}
@errors {400, 403, 404, 429}

@endpoint PUT /api/v1/brands/{brandId}/well-known-uris/{path}/customized
@required {representation: map}
@returns(200) {representation: map, _links: any}
@errors {400, 403, 404, 429}

@endpoint GET /api/v1/captchas
@returns(200)
@errors {403, 429}

@endpoint POST /api/v1/captchas
@optional {id: str, name: str, secretKey: str, siteKey: str, type: str(HCAPTCHA/RECAPTCHA_V2), _links: map{self: any}}
@returns(201) {id: str, name: str, secretKey: str, siteKey: str, type: str, _links: map{self: any}}
@errors {400, 403, 429}

@endpoint GET /api/v1/captchas/{captchaId}
@returns(200) {id: str, name: str, secretKey: str, siteKey: str, type: str, _links: map{self: any}}
@errors {403, 404, 429}

@endpoint POST /api/v1/captchas/{captchaId}
@optional {id: str, name: str, secretKey: str, siteKey: str, type: str(HCAPTCHA/RECAPTCHA_V2), _links: map{self: any}}
@returns(200) {id: str, name: str, secretKey: str, siteKey: str, type: str, _links: map{self: any}}
@errors {400, 403, 404, 429}

@endpoint PUT /api/v1/captchas/{captchaId}
@optional {id: str, name: str, secretKey: str, siteKey: str, type: str(HCAPTCHA/RECAPTCHA_V2), _links: map{self: any}}
@returns(200) {id: str, name: str, secretKey: str, siteKey: str, type: str, _links: map{self: any}}
@errors {400, 403, 404, 429}

@endpoint DELETE /api/v1/captchas/{captchaId}
@returns(204)
@errors {403, 404, 429}

@endpoint GET /api/v1/device-assurances
@returns(200)
@errors {403, 429}

@endpoint POST /api/v1/device-assurances
@optional {createdBy: str, createdDate: str, devicePostureChecks: map{include: [any]}, displayRemediationMode: str(HIDE/SHOW), gracePeriod: map{expiry: any, type: str}, id: str, lastUpdate: str, lastUpdatedBy: str, name: str, platform: str(ANDROID/CHROMEOS/IOS/MACOS/WINDOWS), _links: map{self: any}}
@returns(200) {createdBy: str, createdDate: str, devicePostureChecks: map{include: [any]}, displayRemediationMode: str, gracePeriod: map{expiry: any, type: str}, id: str, lastUpdate: str, lastUpdatedBy: str, name: str, platform: str, _links: map{self: any}}
@errors {400, 403, 429}

@endpoint GET /api/v1/device-assurances/{deviceAssuranceId}
@returns(200) {createdBy: str, createdDate: str, devicePostureChecks: map{include: [any]}, displayRemediationMode: str, gracePeriod: map{expiry: any, type: str}, id: str, lastUpdate: str, lastUpdatedBy: str, name: str, platform: str, _links: map{self: any}}
@errors {403, 404, 429}

@endpoint PUT /api/v1/device-assurances/{deviceAssuranceId}
@optional {createdBy: str, createdDate: str, devicePostureChecks: map{include: [any]}, displayRemediationMode: str(HIDE/SHOW), gracePeriod: map{expiry: any, type: str}, id: str, lastUpdate: str, lastUpdatedBy: str, name: str, platform: str(ANDROID/CHROMEOS/IOS/MACOS/WINDOWS), _links: map{self: any}}
@returns(200) {createdBy: str, createdDate: str, devicePostureChecks: map{include: [any]}, displayRemediationMode: str, gracePeriod: map{expiry: any, type: str}, id: str, lastUpdate: str, lastUpdatedBy: str, name: str, platform: str, _links: map{self: any}}
@errors {400, 403, 404, 429}

@endpoint DELETE /api/v1/device-assurances/{deviceAssuranceId}
@returns(204)
@errors {403, 404, 409, 429}

@endpoint GET /api/v1/device-integrations
@returns(200)
@errors {401, 403, 429}

@endpoint GET /api/v1/device-integrations/{deviceIntegrationId}
@returns(200) {displayName: str, id: str, metadata: map, name: str, platform: str, status: str, _links: any}
@errors {401, 403, 429}

@endpoint POST /api/v1/device-integrations/{deviceIntegrationId}/lifecycle/activate
@returns(200) {displayName: str, id: str, metadata: map, name: str, platform: str, status: str, _links: any}
@errors {401, 403, 404, 429}

@endpoint POST /api/v1/device-integrations/{deviceIntegrationId}/lifecycle/deactivate
@returns(200) {displayName: str, id: str, metadata: map, name: str, platform: str, status: str, _links: any}
@errors {401, 403, 404, 429}

@endpoint GET /api/v1/device-posture-checks
@returns(200)
@errors {403, 429}

@endpoint POST /api/v1/device-posture-checks
@optional {createdBy: str, createdDate: str, description: str, id: str, lastUpdate: str, lastUpdatedBy: str, mappingType: str(CHECKBOX/TEXTBOX), name: str, platform: str(MACOS/WINDOWS), query: str, remediationSettings: map{link: map, message: map}, type: str(BUILTIN/CUSTOM), variableName: str, _links: map{self: any}}
@returns(200) {createdBy: str, createdDate: str, description: str, id: str, lastUpdate: str, lastUpdatedBy: str, mappingType: str, name: str, platform: str, query: str, remediationSettings: map{link: map{defaultUrl: str, customUrl: str}, message: map{defaultI18nKey: str, customText: str}}, type: str, variableName: str, _links: map{self: any}}
@errors {400, 403, 429}

@endpoint GET /api/v1/device-posture-checks/default
@returns(200)
@errors {403, 429}

@endpoint GET /api/v1/device-posture-checks/{postureCheckId}
@returns(200) {createdBy: str, createdDate: str, description: str, id: str, lastUpdate: str, lastUpdatedBy: str, mappingType: str, name: str, platform: str, query: str, remediationSettings: map{link: map{defaultUrl: str, customUrl: str}, message: map{defaultI18nKey: str, customText: str}}, type: str, variableName: str, _links: map{self: any}}
@errors {403, 404, 429}

@endpoint PUT /api/v1/device-posture-checks/{postureCheckId}
@optional {createdBy: str, createdDate: str, description: str, id: str, lastUpdate: str, lastUpdatedBy: str, mappingType: str(CHECKBOX/TEXTBOX), name: str, platform: str(MACOS/WINDOWS), query: str, remediationSettings: map{link: map, message: map}, type: str(BUILTIN/CUSTOM), variableName: str, _links: map{self: any}}
@returns(200) {createdBy: str, createdDate: str, description: str, id: str, lastUpdate: str, lastUpdatedBy: str, mappingType: str, name: str, platform: str, query: str, remediationSettings: map{link: map{defaultUrl: str, customUrl: str}, message: map{defaultI18nKey: str, customText: str}}, type: str, variableName: str, _links: map{self: any}}
@errors {400, 403, 404, 429}

@endpoint DELETE /api/v1/device-posture-checks/{postureCheckId}
@returns(204)
@errors {403, 404, 409, 429}

@endpoint GET /api/v1/devices
@optional {after: str, limit: int=200, search: str, expand: str(user/userSummary)}
@returns(200)
@errors {403, 429}

@endpoint GET /api/v1/devices/{deviceId}
@returns(200) {created: str(date-time), id: str, lastUpdated: str(date-time), profile: map{diskEncryptionType: str, displayName: str, imei: str, integrityJailbreak: bool, managed: bool, manufacturer: str, meid: str, model: str, osVersion: str, platform: str, registered: bool, secureHardwarePresent: bool, serialNumber: str, sid: str, tpmPublicKeyHash: str, udid: str}, resourceAlternateId: str, resourceDisplayName: map{sensitive: bool, value: str}, resourceId: str, resourceType: str, status: str, _links: any}
@errors {403, 404, 429}

@endpoint DELETE /api/v1/devices/{deviceId}
@returns(204)
@errors {403, 404, 429}

@endpoint POST /api/v1/devices/{deviceId}/lifecycle/activate
@returns(204)
@errors {403, 404, 429}

@endpoint POST /api/v1/devices/{deviceId}/lifecycle/deactivate
@returns(204)
@errors {403, 404, 429}

@endpoint POST /api/v1/devices/{deviceId}/lifecycle/suspend
@returns(204)
@errors {403, 404, 429}

@endpoint POST /api/v1/devices/{deviceId}/lifecycle/unsuspend
@returns(204)
@errors {403, 404, 429}

@endpoint GET /api/v1/devices/{deviceId}/users
@returns(200)
@errors {403, 404, 429}

@endpoint POST /api/v1/directories/{appInstanceId}/groups/modify
@optional {id: str, parameters: map{action: str, attribute: str, values: [str]}}
@returns(200)
@errors {400, 403, 404, 502, 504}

@endpoint GET /api/v1/domains
@returns(200) {domains: [map]}
@errors {403, 429}

@endpoint POST /api/v1/domains
@required {certificateSourceType: str(MANUAL/OKTA_MANAGED), domain: str}
@returns(200) {brandId: str, certificateSourceType: str, dnsRecords: [map], domain: str, id: str, publicCertificate: map{expiration: str, fingerprint: str, subject: str}, validationStatus: str, _links: any}
@errors {400, 403, 429}

@endpoint GET /api/v1/domains/{domainId}
@returns(200) {brandId: str, certificateSourceType: str, dnsRecords: [map], domain: str, id: str, publicCertificate: map{expiration: str, fingerprint: str, subject: str}, validationStatus: str, _links: any}
@errors {403, 404, 429}

@endpoint PUT /api/v1/domains/{domainId}
@required {brandId: str}
@returns(200) {brandId: str, certificateSourceType: str, dnsRecords: [map], domain: str, id: str, publicCertificate: map{expiration: str, fingerprint: str, subject: str}, validationStatus: str, _links: any}
@errors {400, 403, 404, 429}

@endpoint DELETE /api/v1/domains/{domainId}
@returns(204)
@errors {403, 404, 429}

@endpoint PUT /api/v1/domains/{domainId}/certificate
@required {certificate: str, certificateChain: str, privateKey: str, type: str}
@returns(204)
@errors {400, 403, 404, 429}

@endpoint POST /api/v1/domains/{domainId}/verify
@returns(200) {brandId: str, certificateSourceType: str, dnsRecords: [map], domain: str, id: str, publicCertificate: map{expiration: str, fingerprint: str, subject: str}, validationStatus: str, _links: any}
@errors {403, 404, 429}

@endpoint GET /api/v1/email-domains
@returns(200)
@errors {403, 429}

@endpoint POST /api/v1/email-domains
@required {brandId: str, domain: str}
@optional {validationSubdomain: str=mail}
@returns(200) {dnsValidationRecords: [map], domain: str, id: str, validationStatus: str, validationSubdomain: str}
@errors {400, 403, 404, 409, 429}

@endpoint GET /api/v1/email-domains/{emailDomainId}
@returns(200) {_embedded: map{brands: [map]}}
@errors {403, 404, 429}

@endpoint PUT /api/v1/email-domains/{emailDomainId}
@returns(200) {dnsValidationRecords: [map], domain: str, id: str, validationStatus: str, validationSubdomain: str}
@errors {400, 403, 404, 429}

@endpoint DELETE /api/v1/email-domains/{emailDomainId}
@returns(204)
@errors {400, 403, 404, 429}

@endpoint POST /api/v1/email-domains/{emailDomainId}/verify
@returns(200) {dnsValidationRecords: [map], domain: str, id: str, validationStatus: str, validationSubdomain: str}
@errors {400, 403, 404, 429}

@endpoint GET /api/v1/email-servers
@returns(200) {email-servers: [any]}
@errors {403, 429}

@endpoint POST /api/v1/email-servers
@returns(201)
@errors {400, 403, 429}

@endpoint GET /api/v1/email-servers/{emailServerId}
@returns(200) {email-servers: [any]}
@errors {403, 404, 429}

@endpoint PATCH /api/v1/email-servers/{emailServerId}
@returns(200)
@errors {400, 403, 404, 429}

@endpoint DELETE /api/v1/email-servers/{emailServerId}
@returns(204)
@errors {403, 404, 429}

@endpoint POST /api/v1/email-servers/{emailServerId}/test
@required {from: str, to: str}
@returns(204)
@errors {400, 403, 404, 429}

@endpoint GET /api/v1/eventHooks
@returns(200)
@errors {403, 429}

@endpoint POST /api/v1/eventHooks
@required {channel: map{config!: map, type!: str, version!: str}, events: map{filter: map, items!: [str], type!: str}, name: str}
@optional {created: str(date-time), createdBy: str, description: str, id: str, lastUpdated: str(date-time), status: str(ACTIVE/INACTIVE), verificationStatus: str(UNVERIFIED/VERIFIED), _links: any}
@returns(200) {channel: map{config: map{authScheme: map{key: str, type: str, value: str}, headers: [map], method: str, uri: str}, type: str, version: str}, created: str(date-time), createdBy: str, description: str?, events: map{filter: map?{eventFilterMap: [map], type: str}, items: [str], type: str}, id: str, lastUpdated: str(date-time), name: str, status: str, verificationStatus: str, _links: any}
@errors {400, 403, 429}

@endpoint GET /api/v1/eventHooks/{eventHookId}
@returns(200) {channel: map{config: map{authScheme: map{key: str, type: str, value: str}, headers: [map], method: str, uri: str}, type: str, version: str}, created: str(date-time), createdBy: str, description: str?, events: map{filter: map?{eventFilterMap: [map], type: str}, items: [str], type: str}, id: str, lastUpdated: str(date-time), name: str, status: str, verificationStatus: str, _links: any}
@errors {403, 404, 429}

@endpoint PUT /api/v1/eventHooks/{eventHookId}
@required {channel: map{config!: map, type!: str, version!: str}, events: map{filter: map, items!: [str], type!: str}, name: str}
@optional {created: str(date-time), createdBy: str, description: str, id: str, lastUpdated: str(date-time), status: str(ACTIVE/INACTIVE), verificationStatus: str(UNVERIFIED/VERIFIED), _links: any}
@returns(200) {channel: map{config: map{authScheme: map{key: str, type: str, value: str}, headers: [map], method: str, uri: str}, type: str, version: str}, created: str(date-time), createdBy: str, description: str?, events: map{filter: map?{eventFilterMap: [map], type: str}, items: [str], type: str}, id: str, lastUpdated: str(date-time), name: str, status: str, verificationStatus: str, _links: any}
@errors {400, 403, 404, 429}

@endpoint DELETE /api/v1/eventHooks/{eventHookId}
@returns(204)
@errors {403, 404, 429}

@endpoint POST /api/v1/eventHooks/{eventHookId}/lifecycle/activate
@returns(200) {channel: map{config: map{authScheme: map{key: str, type: str, value: str}, headers: [map], method: str, uri: str}, type: str, version: str}, created: str(date-time), createdBy: str, description: str?, events: map{filter: map?{eventFilterMap: [map], type: str}, items: [str], type: str}, id: str, lastUpdated: str(date-time), name: str, status: str, verificationStatus: str, _links: any}
@errors {403, 404, 429}

@endpoint POST /api/v1/eventHooks/{eventHookId}/lifecycle/deactivate
@returns(200) {channel: map{config: map{authScheme: map{key: str, type: str, value: str}, headers: [map], method: str, uri: str}, type: str, version: str}, created: str(date-time), createdBy: str, description: str?, events: map{filter: map?{eventFilterMap: [map], type: str}, items: [str], type: str}, id: str, lastUpdated: str(date-time), name: str, status: str, verificationStatus: str, _links: any}
@errors {403, 404, 429}

@endpoint POST /api/v1/eventHooks/{eventHookId}/lifecycle/verify
@returns(200) {channel: map{config: map{authScheme: map{key: str, type: str, value: str}, headers: [map], method: str, uri: str}, type: str, version: str}, created: str(date-time), createdBy: str, description: str?, events: map{filter: map?{eventFilterMap: [map], type: str}, items: [str], type: str}, id: str, lastUpdated: str(date-time), name: str, status: str, verificationStatus: str, _links: any}
@errors {400, 403, 404, 429}

@endpoint GET /api/v1/features
@returns(200)
@errors {403, 429}

@endpoint GET /api/v1/features/{featureId}
@returns(200) {description: str, id: str, name: str, stage: map{state: str, value: str}, status: str, type: str, _links: any}
@errors {403, 404, 429}

@endpoint GET /api/v1/features/{featureId}/dependencies
@returns(200)
@errors {403, 404, 429}

@endpoint GET /api/v1/features/{featureId}/dependents
@returns(200)
@errors {403, 404, 429}

@endpoint POST /api/v1/features/{featureId}/{lifecycle}
@optional {mode: str}
@returns(200) {description: str, id: str, name: str, stage: map{state: str, value: str}, status: str, type: str, _links: any}
@errors {403, 404, 429}

@endpoint GET /api/v1/first-party-app-settings/{appName}
@returns(200) {sessionIdleTimeoutMinutes: int, sessionMaxLifetimeMinutes: int}
@errors {403, 429}

@endpoint PUT /api/v1/first-party-app-settings/{appName}
@optional {sessionIdleTimeoutMinutes: int=15, sessionMaxLifetimeMinutes: int=720}
@returns(200) {sessionIdleTimeoutMinutes: int, sessionMaxLifetimeMinutes: int}
@errors {400, 403, 429}

@endpoint GET /api/v1/groups
@optional {search: str, filter: str, q: str, after: str, limit: int(int32), expand: str, sortBy: str, sortOrder: str=asc}
@returns(200)
@errors {403, 429}

@endpoint POST /api/v1/groups
@optional {profile: map{description: str, name: str}}
@returns(200) {created: str(date-time), id: str, lastMembershipUpdated: str(date-time), lastUpdated: str(date-time), objectClass: [str], profile: any, type: str, _embedded: map, _links: any}
@errors {400, 403, 429}

@endpoint GET /api/v1/groups/rules
@optional {limit: int(int32)=50, after: str, search: str, expand: str}
@returns(200)
@errors {403, 429}

@endpoint POST /api/v1/groups/rules
@optional {actions: map{assignUserToGroups: map}, conditions: map{expression: map, people: map}, name: str, type: str}
@returns(200) {actions: map{assignUserToGroups: map{groupIds: [str]}}, conditions: map{expression: map{type: str, value: str}, people: map{groups: map{exclude: [str]}, users: map{exclude: [str]}}}, created: str(date-time), id: str, lastUpdated: str(date-time), name: str, status: str, type: str}
@errors {400, 403, 429}

@endpoint GET /api/v1/groups/rules/{groupRuleId}
@optional {expand: str}
@returns(200) {actions: map{assignUserToGroups: map{groupIds: [str]}}, conditions: map{expression: map{type: str, value: str}, people: map{groups: map{exclude: [str]}, users: map{exclude: [str]}}}, created: str(date-time), id: str, lastUpdated: str(date-time), name: str, status: str, type: str}
@errors {403, 404, 429}

@endpoint PUT /api/v1/groups/rules/{groupRuleId}
@optional {actions: map{assignUserToGroups: map}, conditions: map{expression: map, people: map}, created: str(date-time), id: str, lastUpdated: str(date-time), name: str, status: str(ACTIVE/INACTIVE/INVALID), type: str}
@returns(200) {actions: map{assignUserToGroups: map{groupIds: [str]}}, conditions: map{expression: map{type: str, value: str}, people: map{groups: map{exclude: [str]}, users: map{exclude: [str]}}}, created: str(date-time), id: str, lastUpdated: str(date-time), name: str, status: str, type: str}
@errors {400, 403, 404, 429}

@endpoint DELETE /api/v1/groups/rules/{groupRuleId}
@optional {removeUsers: bool=false}
@returns(202)
@errors {403, 404, 429}

@endpoint POST /api/v1/groups/rules/{groupRuleId}/lifecycle/activate
@returns(204)
@errors {403, 404, 429}

@endpoint POST /api/v1/groups/rules/{groupRuleId}/lifecycle/deactivate
@returns(204)
@errors {403, 404, 429}

@endpoint GET /api/v1/groups/{groupId}
@returns(200) {created: str(date-time), id: str, lastMembershipUpdated: str(date-time), lastUpdated: str(date-time), objectClass: [str], profile: any, type: str, _embedded: map, _links: any}
@errors {403, 404, 429}

@endpoint PUT /api/v1/groups/{groupId}
@optional {profile: map{description: str, name: str}}
@returns(200) {created: str(date-time), id: str, lastMembershipUpdated: str(date-time), lastUpdated: str(date-time), objectClass: [str], profile: any, type: str, _embedded: map, _links: any}
@errors {400, 403, 404, 429}

@endpoint DELETE /api/v1/groups/{groupId}
@returns(204)
@errors {403, 404, 429}

@endpoint GET /api/v1/groups/{groupId}/apps
@optional {after: str, limit: int(int32)=20}
@returns(200)
@errors {403, 404, 429}

@endpoint GET /api/v1/groups/{groupId}/owners
@optional {search: str, after: str, limit: int(int32)=1000}
@returns(200)
@errors {403, 404, 429}

@endpoint POST /api/v1/groups/{groupId}/owners
@required {groupId: str}
@optional {id: str, type: str(GROUP/USER)}
@returns(201) {displayName: str, id: str, lastUpdated: str(date-time), originId: str, originType: str, resolved: bool, type: str}
@errors {400, 403, 404, 429}

@endpoint DELETE /api/v1/groups/{groupId}/owners/{ownerId}
@returns(204)
@errors {403, 404, 429}

@endpoint GET /api/v1/groups/{groupId}/roles
@optional {expand: str}
@returns(200)
@errors {403, 404, 429}

@endpoint POST /api/v1/groups/{groupId}/roles
@optional {disableNotifications: bool=false}
@returns(200)
@returns(201)
@errors {400, 403, 404, 429}

@endpoint GET /api/v1/groups/{groupId}/roles/{roleAssignmentId}
@returns(200)
@errors {403, 404, 429}

@endpoint DELETE /api/v1/groups/{groupId}/roles/{roleAssignmentId}
@returns(204)
@errors {403, 404, 429}

@endpoint GET /api/v1/groups/{groupId}/roles/{roleAssignmentId}/targets/catalog/apps
@optional {after: str, limit: int=20}
@returns(200)
@errors {403, 404, 429}

@endpoint PUT /api/v1/groups/{groupId}/roles/{roleAssignmentId}/targets/catalog/apps/{appName}
@returns(200)
@errors {403, 404, 429}

@endpoint DELETE /api/v1/groups/{groupId}/roles/{roleAssignmentId}/targets/catalog/apps/{appName}
@returns(204)
@errors {403, 404, 429}

@endpoint PUT /api/v1/groups/{groupId}/roles/{roleAssignmentId}/targets/catalog/apps/{appName}/{appId}
@returns(204)
@errors {403, 404, 429}

@endpoint DELETE /api/v1/groups/{groupId}/roles/{roleAssignmentId}/targets/catalog/apps/{appName}/{appId}
@returns(204)
@errors {403, 404, 429}

@endpoint GET /api/v1/groups/{groupId}/roles/{roleAssignmentId}/targets/groups
@optional {after: str, limit: int=20}
@returns(200)
@errors {403, 404, 429}

@endpoint PUT /api/v1/groups/{groupId}/roles/{roleAssignmentId}/targets/groups/{targetGroupId}
@returns(204)
@errors {403, 404, 429}

@endpoint DELETE /api/v1/groups/{groupId}/roles/{roleAssignmentId}/targets/groups/{targetGroupId}
@returns(204)
@errors {403, 404, 429}

@endpoint GET /api/v1/groups/{groupId}/users
@optional {after: str, limit: int(int32)=1000}
@returns(200)
@errors {403, 404, 429}

@endpoint PUT /api/v1/groups/{groupId}/users/{userId}
@returns(204)
@errors {403, 404, 429}

@endpoint DELETE /api/v1/groups/{groupId}/users/{userId}
@returns(204)
@errors {403, 404, 429}

@endpoint GET /api/v1/hook-keys
@returns(200)
@errors {403, 429}

@endpoint POST /api/v1/hook-keys
@optional {name: str}
@returns(200) {created: str(date-time)?, id: str, isUsed: str(boolean), keyId: str, lastUpdated: str(date-time)?, name: str, _embedded: map{alg: str, e: str, kid: str, kty: str, n: str, use: str?}}
@errors {400, 403, 429}

@endpoint GET /api/v1/hook-keys/public/{keyId}
@returns(200) {alg: str, e: str, kid: str, kty: str, n: str, use: str?}
@errors {403, 404, 429}

@endpoint GET /api/v1/hook-keys/{id}
@optional {id: str}
@returns(200) {created: str(date-time)?, id: str, isUsed: str(boolean), keyId: str, lastUpdated: str(date-time)?, name: str}
@errors {403, 404, 429}

@endpoint PUT /api/v1/hook-keys/{id}
@optional {name: str}
@returns(200) {created: str(date-time)?, id: str, isUsed: str(boolean), keyId: str, lastUpdated: str(date-time)?, name: str, _embedded: map{alg: str, e: str, kid: str, kty: str, n: str, use: str?}}
@errors {400, 403, 404, 429}

@endpoint DELETE /api/v1/hook-keys/{id}
@returns(204)
@errors {403, 404, 429}

@endpoint GET /api/v1/iam/assignees/users
@optional {after: str, limit: int(int32)=100}
@returns(200) {value: [map], _links: map{next: any}}
@errors {403, 429}

@endpoint GET /api/v1/iam/governance/bundles
@optional {after: str, limit: int=20}
@returns(200) {bundles: [map], _links: any}
@errors {403, 429}

@endpoint POST /api/v1/iam/governance/bundles
@optional {description: str, entitlements: [map{resourceSets: [str], role: str, targets: [str]}], name: str}
@returns(200) {description: str, id: str, name: str, orn: str, status: str, _links: any}
@errors {400, 403, 429}

@endpoint GET /api/v1/iam/governance/bundles/{bundleId}
@returns(200) {description: str, id: str, name: str, orn: str, status: str, _links: any}
@errors {400, 403, 429}

@endpoint PUT /api/v1/iam/governance/bundles/{bundleId}
@optional {description: str, entitlements: [map{resourceSets: [str], role: str, targets: [str]}], name: str}
@returns(200) {description: str, id: str, name: str, orn: str, status: str, _links: any}
@errors {400, 403, 429}

@endpoint DELETE /api/v1/iam/governance/bundles/{bundleId}
@returns(204)
@errors {403, 429}

@endpoint GET /api/v1/iam/governance/bundles/{bundleId}/entitlements
@optional {after: str, limit: int=20}
@returns(200) {entitlements: [map], _links: map{next: any, self: any, bundle: any}}
@errors {403, 429}

@endpoint GET /api/v1/iam/governance/bundles/{bundleId}/entitlements/{entitlementId}/values
@optional {after: str, limit: int=20}
@returns(200) {entitlementValues: [map], _links: any}
@errors {403, 429}

@endpoint GET /api/v1/iam/governance/optIn
@returns(200) {optInStatus: str, _links: any}
@errors {403, 429}

@endpoint POST /api/v1/iam/governance/optIn
@returns(200) {optInStatus: str, _links: any}
@errors {403, 429}

@endpoint POST /api/v1/iam/governance/optOut
@returns(200) {optInStatus: str, _links: any}
@errors {403, 429}

@endpoint GET /api/v1/iam/resource-sets
@optional {after: str}
@returns(200) {resource-sets: [map], _links: map{next: map{hints: map{allow: [str]}, href: str, name: str, templated: bool, type: str}}}
@errors {403, 429}

@endpoint POST /api/v1/iam/resource-sets
@required {description: str, label: str, resources: [str]}
@returns(200) {created: str(date-time), description: str, id: str, label: str, lastUpdated: str(date-time), _links: any}
@errors {400, 403, 429}

@endpoint GET /api/v1/iam/resource-sets/{resourceSetIdOrLabel}
@returns(200) {created: str(date-time), description: str, id: str, label: str, lastUpdated: str(date-time), _links: any}
@errors {403, 404, 429}

@endpoint PUT /api/v1/iam/resource-sets/{resourceSetIdOrLabel}
@optional {created: str(date-time), description: str, id: str, label: str, lastUpdated: str(date-time), _links: any}
@returns(200) {created: str(date-time), description: str, id: str, label: str, lastUpdated: str(date-time), _links: any}
@errors {400, 403, 404, 429}

@endpoint DELETE /api/v1/iam/resource-sets/{resourceSetIdOrLabel}
@returns(204)
@errors {403, 404, 429}

@endpoint GET /api/v1/iam/resource-sets/{resourceSetIdOrLabel}/bindings
@optional {after: str}
@returns(200) {roles: [map], _links: any}
@errors {403, 404, 429}

@endpoint POST /api/v1/iam/resource-sets/{resourceSetIdOrLabel}/bindings
@optional {members: [str], role: str}
@returns(200) {_links: any}
@errors {400, 403, 404, 429}

@endpoint GET /api/v1/iam/resource-sets/{resourceSetIdOrLabel}/bindings/{roleIdOrLabel}
@returns(200) {id: str, _links: any}
@errors {403, 404, 429}

@endpoint DELETE /api/v1/iam/resource-sets/{resourceSetIdOrLabel}/bindings/{roleIdOrLabel}
@returns(204)
@errors {403, 404, 429}

@endpoint GET /api/v1/iam/resource-sets/{resourceSetIdOrLabel}/bindings/{roleIdOrLabel}/members
@optional {after: str}
@returns(200) {members: [map], _links: any}
@errors {403, 404, 429}

@endpoint PATCH /api/v1/iam/resource-sets/{resourceSetIdOrLabel}/bindings/{roleIdOrLabel}/members
@optional {additions: [str]}
@returns(200) {_links: any}
@errors {400, 403, 404, 429}

@endpoint GET /api/v1/iam/resource-sets/{resourceSetIdOrLabel}/bindings/{roleIdOrLabel}/members/{memberId}
@returns(200) {created: str(date-time), id: str, lastUpdated: str(date-time), _links: map{self: any}}
@errors {403, 404, 429}

@endpoint DELETE /api/v1/iam/resource-sets/{resourceSetIdOrLabel}/bindings/{roleIdOrLabel}/members/{memberId}
@returns(204)
@errors {403, 404, 429}

@endpoint GET /api/v1/iam/resource-sets/{resourceSetIdOrLabel}/resources
@returns(200) {resources: [map], _links: any}
@errors {403, 404, 429}

@endpoint POST /api/v1/iam/resource-sets/{resourceSetIdOrLabel}/resources
@required {conditions: map{Exclude: map}, resourceOrnOrUrl: str}
@returns(200) {conditions: map{Exclude: map{okta:ORN: [str]}}, created: str(date-time), id: str, lastUpdated: str(date-time), orn: str, _links: any}
@errors {400, 403, 404, 429}

@endpoint PATCH /api/v1/iam/resource-sets/{resourceSetIdOrLabel}/resources
@optional {additions: [str]}
@returns(200) {created: str(date-time), description: str, id: str, label: str, lastUpdated: str(date-time), _links: any}
@errors {400, 403, 404, 429}

@endpoint GET /api/v1/iam/resource-sets/{resourceSetIdOrLabel}/resources/{resourceId}
@returns(200) {conditions: map{Exclude: map{okta:ORN: [str]}}, created: str(date-time), id: str, lastUpdated: str(date-time), orn: str, _links: any}
@errors {400, 403, 404, 429}

@endpoint PUT /api/v1/iam/resource-sets/{resourceSetIdOrLabel}/resources/{resourceId}
@optional {conditions: map{Exclude: map}}
@returns(200) {conditions: map{Exclude: map{okta:ORN: [str]}}, created: str(date-time), id: str, lastUpdated: str(date-time), orn: str, _links: any}
@errors {400, 403, 404, 429}

@endpoint DELETE /api/v1/iam/resource-sets/{resourceSetIdOrLabel}/resources/{resourceId}
@returns(204)
@errors {403, 404, 429}

@endpoint GET /api/v1/iam/roles
@optional {after: str}
@returns(200) {roles: [map], _links: map{next: map{hints: map{allow: [str]}, href: str, name: str, templated: bool, type: str}}}
@errors {403, 429}

@endpoint POST /api/v1/iam/roles
@required {description: str, label: str, permissions: [any]}
@returns(200) {created: str(date-time), description: str, id: str, label: str, lastUpdated: str(date-time), _links: any}
@errors {400, 403, 429}

@endpoint GET /api/v1/iam/roles/{roleIdOrLabel}
@returns(200) {created: str(date-time), description: str, id: str, label: str, lastUpdated: str(date-time), _links: any}
@errors {403, 404, 429}

@endpoint PUT /api/v1/iam/roles/{roleIdOrLabel}
@required {description: str, label: str}
@returns(200) {created: str(date-time), description: str, id: str, label: str, lastUpdated: str(date-time), _links: any}
@errors {400, 403, 404, 429}

@endpoint DELETE /api/v1/iam/roles/{roleIdOrLabel}
@returns(204)
@errors {403, 404, 429}

@endpoint GET /api/v1/iam/roles/{roleIdOrLabel}/permissions
@returns(200) {permissions: [map]}
@errors {403, 404, 429}

@endpoint GET /api/v1/iam/roles/{roleIdOrLabel}/permissions/{permissionType}
@returns(200) {conditions: map?{exclude: map?, include: map?}, created: str(date-time), label: str, lastUpdated: str(date-time), _links: any}
@errors {403, 404, 429}

@endpoint POST /api/v1/iam/roles/{roleIdOrLabel}/permissions/{permissionType}
@optional {conditions: map{exclude: map, include: map}}
@returns(204)
@errors {400, 403, 404, 429}

@endpoint PUT /api/v1/iam/roles/{roleIdOrLabel}/permissions/{permissionType}
@optional {conditions: map{exclude: map, include: map}}
@returns(200) {conditions: map?{exclude: map?, include: map?}, created: str(date-time), label: str, lastUpdated: str(date-time), _links: any}
@errors {400, 403, 404, 429}

@endpoint DELETE /api/v1/iam/roles/{roleIdOrLabel}/permissions/{permissionType}
@returns(204)
@errors {403, 404, 429}

@endpoint GET /api/v1/identity-sources/{identitySourceId}/sessions
@returns(200)
@errors {403, 404, 429}

@endpoint POST /api/v1/identity-sources/{identitySourceId}/sessions
@returns(200) {created: str(date-time), id: str, identitySourceId: str, importType: str, lastUpdated: str(date-time), status: str}
@errors {403, 404, 429}

@endpoint GET /api/v1/identity-sources/{identitySourceId}/sessions/{sessionId}
@returns(200) {created: str(date-time), id: str, identitySourceId: str, importType: str, lastUpdated: str(date-time), status: str}
@errors {403, 404, 429}

@endpoint DELETE /api/v1/identity-sources/{identitySourceId}/sessions/{sessionId}
@returns(204)
@errors {403, 404, 429}

@endpoint POST /api/v1/identity-sources/{identitySourceId}/sessions/{sessionId}/bulk-delete
@optional {entityType: str, profiles: [map{externalId: str}]}
@returns(202)
@errors {400, 403, 404, 429}

@endpoint POST /api/v1/identity-sources/{identitySourceId}/sessions/{sessionId}/bulk-upsert
@optional {entityType: str, profiles: [map{externalId: str, profile: map}]}
@returns(202)
@errors {400, 403, 404, 429}

@endpoint POST /api/v1/identity-sources/{identitySourceId}/sessions/{sessionId}/start-import
@returns(200) {created: str(date-time), id: str, identitySourceId: str, importType: str, lastUpdated: str(date-time), status: str}
@errors {403, 404, 429}

@endpoint GET /api/v1/idps
@optional {q: str, after: str, limit: int=20, type: str}
@returns(200)
@errors {403, 429}

@endpoint POST /api/v1/idps
@optional {created: str(date-time), id: str, issuerMode: str(CUSTOM_URL/DYNAMIC/ORG_URL)=DYNAMIC, lastUpdated: str(date-time), name: str, policy: any, properties: map{aalValue: str, additionalAmr: [str], ialValue: str, inquiryTemplateId!: str}, protocol: any, status: str(ACTIVE/INACTIVE), type: str(AMAZON/APPLE/DISCORD/FACEBOOK/GITHUB/GITLAB/GOOGLE/IDV_CLEAR/IDV_INCODE/IDV_PERSONA/LINKEDIN/LOGINGOV/LOGINGOV_SANDBOX/MICROSOFT/OIDC/OKTA_INTEGRATION/PAYPAL/PAYPAL_SANDBOX/SALESFORCE/SAML2/SPOTIFY/X509/XERO/YAHOO/YAHOOJP), _links: map}
@returns(200) {created: str(date-time), id: str, issuerMode: str, lastUpdated: str(date-time), name: str, policy: any, properties: map?{aalValue: str?, additionalAmr: [str]?, ialValue: str?, inquiryTemplateId: str}, protocol: any, status: str, type: str, _links: map}
@errors {400, 403, 429}

@endpoint GET /api/v1/idps/credentials/keys
@optional {after: str, limit: int=20}
@returns(200)
@errors {403, 429}

@endpoint POST /api/v1/idps/credentials/keys
@required {x5c: [str]}
@returns(200) {created: str(date-time), e: str, expiresAt: str(date-time), kid: str, kty: str, lastUpdated: str(date-time), n: str, use: str, x5c: [str], x5t#S256: str}
@errors {400, 403, 429}

@endpoint GET /api/v1/idps/credentials/keys/{kid}
@returns(200) {created: str(date-time), e: str, expiresAt: str(date-time), kid: str, kty: str, lastUpdated: str(date-time), n: str, use: str, x5c: [str], x5t#S256: str}
@errors {403, 404, 429}

@endpoint PUT /api/v1/idps/credentials/keys/{kid}
@optional {created: str(date-time), e: str, expiresAt: str(date-time), kid: str, kty: str, lastUpdated: str(date-time), n: str, use: str, x5c: [str], x5t#S256: str}
@returns(200) {created: str(date-time), e: str, expiresAt: str(date-time), kid: str, kty: str, lastUpdated: str(date-time), n: str, use: str, x5c: [str], x5t#S256: str}
@errors {400, 403, 404, 429}

@endpoint DELETE /api/v1/idps/credentials/keys/{kid}
@returns(204)
@errors {403, 404, 429}

@endpoint GET /api/v1/idps/{idpId}
@returns(200) {created: str(date-time), id: str, issuerMode: str, lastUpdated: str(date-time), name: str, policy: any, properties: map?{aalValue: str?, additionalAmr: [str]?, ialValue: str?, inquiryTemplateId: str}, protocol: any, status: str, type: str, _links: map}
@errors {403, 404, 429}

@endpoint PUT /api/v1/idps/{idpId}
@optional {created: str(date-time), id: str, issuerMode: str(CUSTOM_URL/DYNAMIC/ORG_URL)=DYNAMIC, lastUpdated: str(date-time), name: str, policy: any, properties: map{aalValue: str, additionalAmr: [str], ialValue: str, inquiryTemplateId!: str}, protocol: any, status: str(ACTIVE/INACTIVE), type: str(AMAZON/APPLE/DISCORD/FACEBOOK/GITHUB/GITLAB/GOOGLE/IDV_CLEAR/IDV_INCODE/IDV_PERSONA/LINKEDIN/LOGINGOV/LOGINGOV_SANDBOX/MICROSOFT/OIDC/OKTA_INTEGRATION/PAYPAL/PAYPAL_SANDBOX/SALESFORCE/SAML2/SPOTIFY/X509/XERO/YAHOO/YAHOOJP), _links: map}
@returns(200) {created: str(date-time), id: str, issuerMode: str, lastUpdated: str(date-time), name: str, policy: any, properties: map?{aalValue: str?, additionalAmr: [str]?, ialValue: str?, inquiryTemplateId: str}, protocol: any, status: str, type: str, _links: map}
@errors {400, 403, 404, 429}

@endpoint DELETE /api/v1/idps/{idpId}
@returns(204)
@errors {403, 404, 429}

@endpoint GET /api/v1/idps/{idpId}/credentials/csrs
@returns(200)
@errors {403, 404, 429}

@endpoint POST /api/v1/idps/{idpId}/credentials/csrs
@optional {subject: map{commonName: str, countryName: str, localityName: str, organizationalUnitName: str, organizationName: str, stateOrProvinceName: str}, subjectAltNames: map{dnsNames: [str]}}
@returns(201) {created: str(date-time), csr: str, id: str, kty: str, _links: map}
@errors {400, 403, 404, 429}

@endpoint GET /api/v1/idps/{idpId}/credentials/csrs/{idpCsrId}
@returns(200) {created: str(date-time), csr: str, id: str, kty: str, _links: map}
@errors {403, 404, 429}

@endpoint DELETE /api/v1/idps/{idpId}/credentials/csrs/{idpCsrId}
@returns(204)
@errors {403, 404, 429}

@endpoint POST /api/v1/idps/{idpId}/credentials/csrs/{idpCsrId}/lifecycle/publish
@returns(201) {created: str(date-time), e: str, expiresAt: str(date-time), kid: str, kty: str, lastUpdated: str(date-time), n: str, use: str, x5c: [str], x5t#S256: str}
@errors {400, 403, 404, 429}

@endpoint GET /api/v1/idps/{idpId}/credentials/keys
@returns(200)
@errors {403, 404, 429}

@endpoint GET /api/v1/idps/{idpId}/credentials/keys/active
@returns(200)
@returns(204)
@errors {429}

@endpoint POST /api/v1/idps/{idpId}/credentials/keys/generate
@required {validityYears: int(int32)}
@returns(200) {created: str(date-time), e: str, expiresAt: str(date-time), kid: str, kty: str, lastUpdated: str(date-time), n: str, use: str, x5c: [str], x5t#S256: str}
@errors {403, 404, 429}

@endpoint GET /api/v1/idps/{idpId}/credentials/keys/{kid}
@returns(200) {created: str(date-time), e: str, expiresAt: str(date-time), kid: str, kty: str, lastUpdated: str(date-time), n: str, use: str, x5c: [str], x5t#S256: str}
@errors {403, 404, 429}

@endpoint POST /api/v1/idps/{idpId}/credentials/keys/{kid}/clone
@required {targetIdpId: str}
@returns(201) {created: str(date-time), e: str, expiresAt: str(date-time), kid: str, kty: str, lastUpdated: str(date-time), n: str, use: str, x5c: [str], x5t#S256: str}
@errors {403, 404, 429}

@endpoint POST /api/v1/idps/{idpId}/lifecycle/activate
@returns(200) {created: str(date-time), id: str, issuerMode: str, lastUpdated: str(date-time), name: str, policy: any, properties: map?{aalValue: str?, additionalAmr: [str]?, ialValue: str?, inquiryTemplateId: str}, protocol: any, status: str, type: str, _links: map}
@errors {403, 404, 429}

@endpoint POST /api/v1/idps/{idpId}/lifecycle/deactivate
@returns(200) {created: str(date-time), id: str, issuerMode: str, lastUpdated: str(date-time), name: str, policy: any, properties: map?{aalValue: str?, additionalAmr: [str]?, ialValue: str?, inquiryTemplateId: str}, protocol: any, status: str, type: str, _links: map}
@errors {403, 404, 429}

@endpoint GET /api/v1/idps/{idpId}/users
@optional {q: str, after: str, limit: int=20, expand: str}
@returns(200)
@errors {403, 404, 429}

@endpoint GET /api/v1/idps/{idpId}/users/{userId}
@returns(200) {created: str(date-time), externalId: str, id: str, lastUpdated: str(date-time), profile: map, _embedded: map, _links: map}
@errors {403, 404, 429}

@endpoint POST /api/v1/idps/{idpId}/users/{userId}
@optional {externalId: str}
@returns(200) {created: str(date-time), externalId: str, id: str, lastUpdated: str(date-time), profile: map, _embedded: map, _links: map}
@errors {400, 403, 404, 429}

@endpoint DELETE /api/v1/idps/{idpId}/users/{userId}
@returns(204)
@errors {403, 404, 429}

@endpoint GET /api/v1/idps/{idpId}/users/{userId}/credentials/tokens
@returns(200)
@errors {403, 404, 429}

@endpoint GET /api/v1/inlineHooks
@optional {type: str(com.okta.import.transform/com.okta.oauth2.tokens.transform/com.okta.saml.tokens.transform/com.okta.user.credential.password.import/com.okta.user.pre-registration/com.okta.telephony.provider)}
@returns(200)
@errors {403, 429}

@endpoint POST /api/v1/inlineHooks
@optional {channel: map{type: str, version: str}, name: str, type: str(com.okta.import.transform/com.okta.oauth2.tokens.transform/com.okta.saml.tokens.transform/com.okta.telephony.provider/com.okta.user.credential.password.import/com.okta.user.pre-registration), version: str}
@returns(200) {channel: map{type: str, version: str}, created: str(date-time), id: str, lastUpdated: str(date-time), name: str, status: str, type: str, version: str, _links: any}
@errors {400, 403, 429}

@endpoint GET /api/v1/inlineHooks/{inlineHookId}
@returns(200) {channel: map{type: str, version: str}, created: str(date-time), id: str, lastUpdated: str(date-time), name: str, status: str, type: str, version: str, _links: any}
@errors {403, 404, 429}

@endpoint POST /api/v1/inlineHooks/{inlineHookId}
@optional {channel: map{type: str, version: str}, name: str, version: str}
@returns(200) {channel: map{type: str, version: str}, created: str(date-time), id: str, lastUpdated: str(date-time), name: str, status: str, type: str, version: str, _links: any}
@errors {400, 403, 404, 429}

@endpoint PUT /api/v1/inlineHooks/{inlineHookId}
@optional {channel: map{type: str, version: str}, name: str, version: str}
@returns(200) {channel: map{type: str, version: str}, created: str(date-time), id: str, lastUpdated: str(date-time), name: str, status: str, type: str, version: str, _links: any}
@errors {400, 403, 404, 429}

@endpoint DELETE /api/v1/inlineHooks/{inlineHookId}
@returns(204)
@errors {403, 404, 429}

@endpoint POST /api/v1/inlineHooks/{inlineHookId}/execute
@returns(200)
@errors {400, 403, 404, 429}

@endpoint POST /api/v1/inlineHooks/{inlineHookId}/lifecycle/activate
@returns(200) {channel: map{type: str, version: str}, created: str(date-time), id: str, lastUpdated: str(date-time), name: str, status: str, type: str, version: str, _links: any}
@errors {403, 404, 429}

@endpoint POST /api/v1/inlineHooks/{inlineHookId}/lifecycle/deactivate
@returns(200) {channel: map{type: str, version: str}, created: str(date-time), id: str, lastUpdated: str(date-time), name: str, status: str, type: str, version: str, _links: any}
@errors {403, 404, 429}

@endpoint GET /api/v1/logStreams
@optional {after: str, limit: int=20, filter: str}
@returns(200)
@errors {403, 429}

@endpoint POST /api/v1/logStreams
@required {created: str(date-time), id: str, lastUpdated: str(date-time), name: str, status: str(ACTIVE/INACTIVE), type: str(aws_eventbridge/splunk_cloud_logstreaming), _links: map{activate: any, deactivate: any, self!: any}}
@returns(200) {created: str(date-time), id: str, lastUpdated: str(date-time), name: str, status: str, type: str, _links: map{activate: any, deactivate: any, self: any}}
@errors {400, 403, 429}

@endpoint GET /api/v1/logStreams/{logStreamId}
@returns(200) {created: str(date-time), id: str, lastUpdated: str(date-time), name: str, status: str, type: str, _links: map{activate: any, deactivate: any, self: any}}
@errors {403, 404, 429}

@endpoint PUT /api/v1/logStreams/{logStreamId}
@required {name: str, type: str(aws_eventbridge/splunk_cloud_logstreaming)}
@returns(200) {created: str(date-time), id: str, lastUpdated: str(date-time), name: str, status: str, type: str, _links: map{activate: any, deactivate: any, self: any}}
@errors {400, 403, 404, 429}

@endpoint DELETE /api/v1/logStreams/{logStreamId}
@returns(204)
@errors {403, 404, 429}

@endpoint POST /api/v1/logStreams/{logStreamId}/lifecycle/activate
@returns(200) {created: str(date-time), id: str, lastUpdated: str(date-time), name: str, status: str, type: str, _links: map{activate: any, deactivate: any, self: any}}
@errors {403, 404, 429}

@endpoint POST /api/v1/logStreams/{logStreamId}/lifecycle/deactivate
@returns(200) {created: str(date-time), id: str, lastUpdated: str(date-time), name: str, status: str, type: str, _links: map{activate: any, deactivate: any, self: any}}
@errors {403, 404, 429}

@endpoint GET /api/v1/logs
@optional {since: str(ISO 8601 compliant timestamp)=7 days prior to until, until: str(ISO 8601 compliant timestamp)=current time, after: str(Opaque token), filter: str(SCIM Filter expression), q: str(URL encoded string. Max length is 40 characters per keyword, with a maximum of 10 keyword filters per query (before encoding)), limit: int(Integer between 0 and 1000)=100, sortOrder: str(ASCENDING/DESCENDING)=ASCENDING}
@returns(200)
@errors {400, 403, 429}

@endpoint GET /api/v1/mappings
@optional {after: str, limit: int(int32)=20, sourceId: str, targetId: str}
@returns(200)
@errors {403, 429}

@endpoint GET /api/v1/mappings/{mappingId}
@returns(200) {id: str, properties: map{expression: str, pushStatus: str}, source: map{id: str, name: str, type: str, _links: any}, target: map{id: str, name: str, type: str, _links: any}, _links: map{self: any}}
@errors {403, 404, 429}

@endpoint POST /api/v1/mappings/{mappingId}
@required {properties: map{expression: str, pushStatus: str}}
@returns(200) {id: str, properties: map{expression: str, pushStatus: str}, source: map{id: str, name: str, type: str, _links: any}, target: map{id: str, name: str, type: str, _links: any}, _links: map{self: any}}
@errors {400, 403, 404, 429}

@endpoint GET /api/v1/meta/schemas/apps/{appId}/default
@returns(200) {$schema: str, created: str, definitions: any, id: str, lastUpdated: str, name: str, properties: any, title: str, type: str, _links: map{self: any}}
@errors {403, 404, 429}

@endpoint POST /api/v1/meta/schemas/apps/{appId}/default
@optional {$schema: str, created: str, definitions: any, id: str, lastUpdated: str, name: str, properties: any, title: str, type: str, _links: map{self: any}}
@returns(200) {$schema: str, created: str, definitions: any, id: str, lastUpdated: str, name: str, properties: any, title: str, type: str, _links: map{self: any}}
@errors {400, 403, 404, 429}

@endpoint GET /api/v1/meta/schemas/group/default
@returns(200) {$schema: str, created: str, definitions: map{base: map{id: str, properties: any, required: [str], type: str}, custom: map{id: str, properties: map, required: [str], type: str}}, description: str, id: str, lastUpdated: str, name: str, properties: map{profile: map{allOf: [map]}}, title: str, type: str, _links: map{self: any}}
@errors {403, 429}

@endpoint POST /api/v1/meta/schemas/group/default
@optional {$schema: str, created: str, definitions: map{base: map, custom: map}, description: str, id: str, lastUpdated: str, name: str, properties: map{profile: map}, title: str, type: str, _links: map{self: any}}
@returns(200) {$schema: str, created: str, definitions: map{base: map{id: str, properties: any, required: [str], type: str}, custom: map{id: str, properties: map, required: [str], type: str}}, description: str, id: str, lastUpdated: str, name: str, properties: map{profile: map{allOf: [map]}}, title: str, type: str, _links: map{self: any}}
@errors {400, 403, 429}

@endpoint GET /api/v1/meta/schemas/logStream
@returns(200)
@errors {403, 429}

@endpoint GET /api/v1/meta/schemas/logStream/{logStreamType}
@returns(200) {$schema: str, errorMessage: map, id: str, oneOf: [map]?, pattern: str, properties: map, required: [str], title: str, type: str, _links: map{self: any}}
@errors {403, 404, 429}

@endpoint GET /api/v1/meta/schemas/user/linkedObjects
@returns(200)
@errors {403, 429}

@endpoint POST /api/v1/meta/schemas/user/linkedObjects
@optional {associated: map{description: str, name!: str, title!: str, type!: str}, primary: map{description: str, name!: str, title!: str, type!: str}, _links: map{self: map}}
@returns(201) {associated: map{description: str, name: str, title: str, type: str}, primary: map{description: str, name: str, title: str, type: str}, _links: map{self: map{href: str}}}
@errors {400, 403, 409, 429}

@endpoint GET /api/v1/meta/schemas/user/linkedObjects/{linkedObjectName}
@returns(200) {associated: map{description: str, name: str, title: str, type: str}, primary: map{description: str, name: str, title: str, type: str}, _links: map{self: map{href: str}}}
@errors {403, 404, 429}

@endpoint DELETE /api/v1/meta/schemas/user/linkedObjects/{linkedObjectName}
@returns(204)
@errors {403, 404, 429}

@endpoint GET /api/v1/meta/schemas/user/{schemaId}
@returns(200) {$schema: str, created: str, definitions: any, id: str, lastUpdated: str, name: str, properties: any, title: str, type: str, _links: map{self: any}}
@errors {403, 404, 429}

@endpoint POST /api/v1/meta/schemas/user/{schemaId}
@optional {$schema: str, created: str, definitions: any, id: str, lastUpdated: str, name: str, properties: any, title: str, type: str, _links: map{self: any}}
@returns(200) {$schema: str, created: str, definitions: any, id: str, lastUpdated: str, name: str, properties: any, title: str, type: str, _links: map{self: any}}
@errors {400, 403, 404, 429}

@endpoint GET /api/v1/meta/types/user
@returns(200)
@errors {403, 429}

@endpoint POST /api/v1/meta/types/user
@required {displayName: str, name: str}
@optional {created: str(date-time), createdBy: str, default: bool, description: str, id: str, lastUpdated: str(date-time), lastUpdatedBy: str, _links: any}
@returns(200) {created: str(date-time), createdBy: str, default: bool, description: str, displayName: str, id: str, lastUpdated: str(date-time), lastUpdatedBy: str, name: str, _links: any}
@errors {400, 403, 429}

@endpoint GET /api/v1/meta/types/user/{typeId}
@returns(200) {created: str(date-time), createdBy: str, default: bool, description: str, displayName: str, id: str, lastUpdated: str(date-time), lastUpdatedBy: str, name: str, _links: any}
@errors {403, 404, 429}

@endpoint POST /api/v1/meta/types/user/{typeId}
@optional {description: str, displayName: str}
@returns(200) {created: str(date-time), createdBy: str, default: bool, description: str, displayName: str, id: str, lastUpdated: str(date-time), lastUpdatedBy: str, name: str, _links: any}
@errors {400, 403, 404, 429}

@endpoint PUT /api/v1/meta/types/user/{typeId}
@required {description: str, displayName: str, name: str}
@returns(200) {created: str(date-time), createdBy: str, default: bool, description: str, displayName: str, id: str, lastUpdated: str(date-time), lastUpdatedBy: str, name: str, _links: any}
@errors {400, 403, 404, 429}

@endpoint DELETE /api/v1/meta/types/user/{typeId}
@returns(204)
@errors {403, 404, 429}

@endpoint GET /api/v1/meta/uischemas
@returns(200)
@errors {403, 429}

@endpoint POST /api/v1/meta/uischemas
@optional {uiSchema: map{buttonLabel: str, elements: map, label: str, type: str}}
@returns(200) {created: str(date-time), id: str, lastUpdated: str(date-time), uiSchema: map{buttonLabel: str, elements: map{label: str, options: map{format: str}, scope: str, type: str}, label: str, type: str}, _links: map{self: any}}
@errors {400, 403, 429}

@endpoint GET /api/v1/meta/uischemas/{id}
@returns(200) {created: str(date-time), id: str, lastUpdated: str(date-time), uiSchema: map{buttonLabel: str, elements: map{label: str, options: map{format: str}, scope: str, type: str}, label: str, type: str}, _links: map{self: any}}
@errors {403, 404, 429}

@endpoint PUT /api/v1/meta/uischemas/{id}
@optional {uiSchema: map{buttonLabel: str, elements: map, label: str, type: str}}
@returns(200) {created: str(date-time), id: str, lastUpdated: str(date-time), uiSchema: map{buttonLabel: str, elements: map{label: str, options: map{format: str}, scope: str, type: str}, label: str, type: str}, _links: map{self: any}}
@errors {400, 403, 404, 429}

@endpoint DELETE /api/v1/meta/uischemas/{id}
@returns(204)
@errors {400, 403, 404, 429}

@endpoint GET /api/v1/org
@returns(200) {address1: str, address2: str, city: str, companyName: str, country: str, created: str(date-time), endUserSupportHelpURL: str, expiresAt: str(date-time), id: str, lastUpdated: str(date-time), phoneNumber: str, postalCode: str, state: str, status: str, subdomain: str, supportPhoneNumber: str, website: str, _links: map{contacts: any, logo: any, oktaCommunication: any, oktaSupport: any, preferences: any, uploadLogo: any}}
@errors {403, 429}

@endpoint POST /api/v1/org
@optional {address1: str, address2: str, city: str, companyName: str, country: str, created: str(date-time), endUserSupportHelpURL: str, expiresAt: str(date-time), id: str, lastUpdated: str(date-time), phoneNumber: str, postalCode: str, state: str, status: str(ACTIVE/INACTIVE), subdomain: str, supportPhoneNumber: str, website: str, _links: map{contacts: any, logo: any, oktaCommunication: any, oktaSupport: any, preferences: any, uploadLogo: any}}
@returns(200) {address1: str, address2: str, city: str, companyName: str, country: str, created: str(date-time), endUserSupportHelpURL: str, expiresAt: str(date-time), id: str, lastUpdated: str(date-time), phoneNumber: str, postalCode: str, state: str, status: str, subdomain: str, supportPhoneNumber: str, website: str, _links: map{contacts: any, logo: any, oktaCommunication: any, oktaSupport: any, preferences: any, uploadLogo: any}}
@errors {400, 403, 429}

@endpoint PUT /api/v1/org
@optional {address1: str, address2: str, city: str, companyName: str, country: str, created: str(date-time), endUserSupportHelpURL: str, expiresAt: str(date-time), id: str, lastUpdated: str(date-time), phoneNumber: str, postalCode: str, state: str, status: str(ACTIVE/INACTIVE), subdomain: str, supportPhoneNumber: str, website: str, _links: map{contacts: any, logo: any, oktaCommunication: any, oktaSupport: any, preferences: any, uploadLogo: any}}
@returns(200) {address1: str, address2: str, city: str, companyName: str, country: str, created: str(date-time), endUserSupportHelpURL: str, expiresAt: str(date-time), id: str, lastUpdated: str(date-time), phoneNumber: str, postalCode: str, state: str, status: str, subdomain: str, supportPhoneNumber: str, website: str, _links: map{contacts: any, logo: any, oktaCommunication: any, oktaSupport: any, preferences: any, uploadLogo: any}}
@errors {400, 403, 429}

@endpoint GET /api/v1/org/captcha
@returns(200) {captchaId: str, enabledPages: [str], _links: map{self: map{hints: map{allow: [str]}, href: str, name: str, templated: bool, type: str}}}
@errors {403, 429}

@endpoint PUT /api/v1/org/captcha
@optional {captchaId: str, enabledPages: [str], _links: map{self: map}}
@returns(200) {captchaId: str, enabledPages: [str], _links: map{self: map{hints: map{allow: [str]}, href: str, name: str, templated: bool, type: str}}}
@errors {400, 403, 429}

@endpoint DELETE /api/v1/org/captcha
@returns(204)
@errors {403, 404, 429}

@endpoint GET /api/v1/org/contacts
@returns(200)
@errors {403, 429}

@endpoint GET /api/v1/org/contacts/{contactType}
@returns(200) {userId: str, _links: map{user: any}}
@errors {403, 404, 429}

@endpoint PUT /api/v1/org/contacts/{contactType}
@optional {userId: str, _links: map{user: any}}
@returns(200) {userId: str, _links: map{user: any}}
@errors {400, 403, 404, 429}

@endpoint POST /api/v1/org/email/bounces/remove-list
@optional {emailAddresses: [str]}
@returns(200) {errors: [map]}
@errors {400, 403, 429}

@endpoint GET /api/v1/org/factors/yubikey_token/tokens
@returns(200)
@errors {403, 404, 429}

@endpoint POST /api/v1/org/factors/yubikey_token/tokens
@optional {serialNumber: str, publicId: str, privateId: str, aesKey: str}
@returns(200) {created: str(date-time), id: str, lastUpdated: str(date-time), lastVerified: str(date-time), profile: map, status: str, _embedded: map, _links: any}
@errors {400, 403, 404, 429}

@endpoint GET /api/v1/org/factors/yubikey_token/tokens/{tokenId}
@required {tokenId: str}
@returns(200) {created: str(date-time), id: str, lastUpdated: str(date-time), lastVerified: str(date-time), profile: map, status: str, _embedded: map, _links: any}
@errors {403, 404, 429}

@endpoint POST /api/v1/org/logo
@returns(201)
@errors {400, 403, 429}

@endpoint GET /api/v1/org/orgSettings/thirdPartyAdminSetting
@returns(200) {thirdPartyAdmin: bool}
@errors {403, 429}

@endpoint POST /api/v1/org/orgSettings/thirdPartyAdminSetting
@optional {thirdPartyAdmin: bool}
@returns(200) {thirdPartyAdmin: bool}
@errors {403, 429}

@endpoint GET /api/v1/org/preferences
@returns(200) {showEndUserFooter: bool, _links: map{hideEndUserFooter: any, showEndUserFooter: any}}
@errors {403, 429}

@endpoint POST /api/v1/org/preferences/hideEndUserFooter
@returns(200) {showEndUserFooter: bool, _links: map{hideEndUserFooter: any, showEndUserFooter: any}}
@errors {403, 429}

@endpoint POST /api/v1/org/preferences/showEndUserFooter
@returns(200) {showEndUserFooter: bool, _links: map{hideEndUserFooter: any, showEndUserFooter: any}}
@errors {403, 429}

@endpoint GET /api/v1/org/privacy/aerial
@returns(200) {accountId: str, grantedBy: str, grantedDate: str, _links: any}
@errors {400, 403, 404, 429}

@endpoint POST /api/v1/org/privacy/aerial/grant
@required {accountId: str}
@returns(200) {accountId: str, grantedBy: str, grantedDate: str, _links: any}
@errors {400, 403, 429}

@endpoint POST /api/v1/org/privacy/aerial/revoke
@required {accountId: str}
@returns(200) {_links: any}
@errors {400, 403, 429}

@endpoint GET /api/v1/org/privacy/oktaCommunication
@returns(200) {optOutEmailUsers: bool, _links: map{optIn: any, optOut: any}}
@errors {403, 429}

@endpoint POST /api/v1/org/privacy/oktaCommunication/optIn
@returns(200) {optOutEmailUsers: bool, _links: map{optIn: any, optOut: any}}
@errors {403, 429}

@endpoint POST /api/v1/org/privacy/oktaCommunication/optOut
@returns(200) {optOutEmailUsers: bool, _links: map{optIn: any, optOut: any}}
@errors {403, 429}

@endpoint GET /api/v1/org/privacy/oktaSupport
@returns(200) {caseNumber: str?, expiration: str(date-time)?, support: str, _links: map{extend: any, revoke: any, grant: any, case: any, cases: any}}
@errors {403, 429}

@endpoint GET /api/v1/org/privacy/oktaSupport/cases
@returns(200) {supportCases: [map]}
@errors {403, 429}

@endpoint PATCH /api/v1/org/privacy/oktaSupport/cases/{caseNumber}
@optional {caseNumber: str, impersonation: map{status: str, expiration: str(date-time)}, selfAssigned: map{status: str}, subject: str}
@returns(200) {caseNumber: str, impersonation: map{status: str, expiration: str(date-time)?}, selfAssigned: map{status: str}, subject: str}
@errors {403, 429}

@endpoint POST /api/v1/org/privacy/oktaSupport/extend
@errors {301}

@endpoint POST /api/v1/org/privacy/oktaSupport/grant
@errors {301}

@endpoint POST /api/v1/org/privacy/oktaSupport/revoke
@errors {301}

@endpoint GET /api/v1/org/settings/autoAssignAdminAppSetting
@returns(200) {autoAssignAdminAppSetting: bool}
@errors {403, 429}

@endpoint POST /api/v1/org/settings/autoAssignAdminAppSetting
@optional {autoAssignAdminAppSetting: bool}
@returns(200) {autoAssignAdminAppSetting: bool}
@errors {403, 429}

@endpoint GET /api/v1/org/settings/clientPrivilegesSetting
@returns(200) {clientPrivilegesSetting: bool}
@errors {403, 429}

@endpoint PUT /api/v1/org/settings/clientPrivilegesSetting
@optional {clientPrivilegesSetting: bool}
@returns(200) {clientPrivilegesSetting: bool}
@errors {403, 429}

@endpoint POST /api/v1/orgs
@required {admin: map{credentials: map, profile!: map}, edition: str, name: str(utf-8), subdomain: str}
@optional {created: str(date-time), id: str, lastUpdated: str(date-time), settings: map, status: str, token: str, tokenType: str, website: str, _links: map}
@returns(201) {admin: map{credentials: map{password: map{value: str(password)}, recovery_question: map{answer: str, question: str}}, profile: map{firstName: str?, lastName: str?, email: str(email), login: str}}, created: str(date-time), edition: str, id: str, lastUpdated: str(date-time), name: str(utf-8), settings: map, status: str, subdomain: str, token: str, tokenType: str, website: str, _links: map}
@errors {400, 401, 403, 429, 500}

@endpoint GET /api/v1/policies
@required {type: str(OKTA_SIGN_ON/PASSWORD/MFA_ENROLL/IDP_DISCOVERY/ACCESS_POLICY/DEVICE_SIGNAL_COLLECTION/PROFILE_ENROLLMENT/POST_AUTH_SESSION/ENTITY_RISK)}
@optional {status: str, q: str, expand: str=, sortBy: str, limit: str, resourceId: str, after: str}
@returns(200) {created: str(date-time), description: str, id: str, lastUpdated: str(date-time), name: str, priority: int, status: any, system: bool, type: str, _embedded: map, _links: map{activate: any, deactivate: any, mappings: any, rules: any, self: any}}
@errors {403, 429}

@endpoint POST /api/v1/policies
@required {name: str, type: str(<x-lifecycle class="ea"></x-lifecycle> DEVICE_SIGNAL_COLLECTION/ACCESS_POLICY/ENTITY_RISK/IDP_DISCOVERY/MFA_ENROLL/OKTA_SIGN_ON/PASSWORD/POST_AUTH_SESSION/PROFILE_ENROLLMENT)}
@optional {activate: bool=true, created: str(date-time)=Assigned, description: str=null, id: str=Assigned, lastUpdated: str(date-time)=Assigned, priority: int=Last / Lowest Priority, for example `1`, status: any, system: bool=false, _embedded: map, _links: map{activate: any, deactivate: any, mappings: any, rules: any, self: any}}
@returns(200) {created: str(date-time), description: str, id: str, lastUpdated: str(date-time), name: str, priority: int, status: any, system: bool, type: str, _embedded: map, _links: map{activate: any, deactivate: any, mappings: any, rules: any, self: any}}
@errors {400, 403, 429}

@endpoint POST /api/v1/policies/simulate
@returns(200)
@errors {403, 404, 429}

@endpoint GET /api/v1/policies/{policyId}
@optional {expand: str=}
@returns(200) {created: str(date-time), description: str, id: str, lastUpdated: str(date-time), name: str, priority: int, status: any, system: bool, type: str, _embedded: map, _links: map{activate: any, deactivate: any, mappings: any, rules: any, self: any}}
@errors {403, 404, 429}

@endpoint PUT /api/v1/policies/{policyId}
@required {name: str, type: str(<x-lifecycle class="ea"></x-lifecycle> DEVICE_SIGNAL_COLLECTION/ACCESS_POLICY/ENTITY_RISK/IDP_DISCOVERY/MFA_ENROLL/OKTA_SIGN_ON/PASSWORD/POST_AUTH_SESSION/PROFILE_ENROLLMENT)}
@optional {created: str(date-time)=Assigned, description: str=null, id: str=Assigned, lastUpdated: str(date-time)=Assigned, priority: int=Last / Lowest Priority, for example `1`, status: any, system: bool=false, _embedded: map, _links: map{activate: any, deactivate: any, mappings: any, rules: any, self: any}}
@returns(200) {created: str(date-time), description: str, id: str, lastUpdated: str(date-time), name: str, priority: int, status: any, system: bool, type: str, _embedded: map, _links: map{activate: any, deactivate: any, mappings: any, rules: any, self: any}}
@errors {400, 403, 404, 429}

@endpoint DELETE /api/v1/policies/{policyId}
@returns(204)
@errors {403, 404, 429}

@endpoint GET /api/v1/policies/{policyId}/app
@returns(200)
@errors {403, 404, 429}

@endpoint POST /api/v1/policies/{policyId}/clone
@returns(200) {created: str(date-time), description: str, id: str, lastUpdated: str(date-time), name: str, priority: int, status: any, system: bool, type: str, _embedded: map, _links: map{activate: any, deactivate: any, mappings: any, rules: any, self: any}}
@errors {400, 403, 404, 429}

@endpoint POST /api/v1/policies/{policyId}/lifecycle/activate
@returns(204)
@errors {403, 404, 429}

@endpoint POST /api/v1/policies/{policyId}/lifecycle/deactivate
@returns(204)
@errors {403, 404, 429}

@endpoint GET /api/v1/policies/{policyId}/mappings
@returns(200)
@errors {403, 404, 429}

@endpoint POST /api/v1/policies/{policyId}/mappings
@optional {resourceId: str, resourceType: str(ACCESS_POLICY/APP)}
@returns(200) {id: str, _links: any}
@errors {400, 403, 404, 429}

@endpoint GET /api/v1/policies/{policyId}/mappings/{mappingId}
@returns(200) {id: str, _links: any}
@errors {403, 404, 429}

@endpoint DELETE /api/v1/policies/{policyId}/mappings/{mappingId}
@returns(204)
@errors {403, 404, 429}

@endpoint GET /api/v1/policies/{policyId}/rules
@returns(200)
@errors {403, 404, 429}

@endpoint POST /api/v1/policies/{policyId}/rules
@optional {activate: bool=true, created: str(date-time), id: str, lastUpdated: str(date-time), name: str, priority: int, status: any, system: bool=false, type: str(ACCESS_POLICY/DEVICE_SIGNAL_COLLECTION/ENTITY_RISK/IDP_DISCOVERY/MFA_ENROLL/PASSWORD/POST_AUTH_SESSION/PROFILE_ENROLLMENT/SIGN_ON), _links: map{activate: any, deactivate: any, mappings: any, rules: any, self: any}}
@returns(200) {created: str(date-time)?, id: str, lastUpdated: str(date-time)?, name: str, priority: int?, status: any, system: bool, type: str, _links: map{activate: any, deactivate: any, mappings: any, rules: any, self: any}}
@errors {400, 403, 404, 429}

@endpoint GET /api/v1/policies/{policyId}/rules/{ruleId}
@returns(200) {created: str(date-time)?, id: str, lastUpdated: str(date-time)?, name: str, priority: int?, status: any, system: bool, type: str, _links: map{activate: any, deactivate: any, mappings: any, rules: any, self: any}}
@errors {403, 404, 429}

@endpoint PUT /api/v1/policies/{policyId}/rules/{ruleId}
@optional {created: str(date-time), id: str, lastUpdated: str(date-time), name: str, priority: int, status: any, system: bool=false, type: str(ACCESS_POLICY/DEVICE_SIGNAL_COLLECTION/ENTITY_RISK/IDP_DISCOVERY/MFA_ENROLL/PASSWORD/POST_AUTH_SESSION/PROFILE_ENROLLMENT/SIGN_ON), _links: map{activate: any, deactivate: any, mappings: any, rules: any, self: any}}
@returns(200) {created: str(date-time)?, id: str, lastUpdated: str(date-time)?, name: str, priority: int?, status: any, system: bool, type: str, _links: map{activate: any, deactivate: any, mappings: any, rules: any, self: any}}
@errors {400, 403, 404, 429}

@endpoint DELETE /api/v1/policies/{policyId}/rules/{ruleId}
@returns(204)
@errors {403, 404, 429}

@endpoint POST /api/v1/policies/{policyId}/rules/{ruleId}/lifecycle/activate
@returns(204)
@errors {403, 404, 429}

@endpoint POST /api/v1/policies/{policyId}/rules/{ruleId}/lifecycle/deactivate
@returns(204)
@errors {403, 404, 429}

@endpoint GET /api/v1/principal-rate-limits
@required {filter: str}
@optional {after: str, limit: int(int32)=20}
@returns(200)
@errors {400, 403, 429}

@endpoint POST /api/v1/principal-rate-limits
@required {principalId: str, principalType: str(OAUTH_CLIENT/SSWS_TOKEN)}
@optional {createdBy: str, createdDate: str(date-time), defaultConcurrencyPercentage: int, defaultPercentage: int, id: str, lastUpdate: str(date-time), lastUpdatedBy: str, orgId: str}
@returns(201) {createdBy: str, createdDate: str(date-time), defaultConcurrencyPercentage: int, defaultPercentage: int, id: str, lastUpdate: str(date-time), lastUpdatedBy: str, orgId: str, principalId: str, principalType: str}
@errors {400, 403, 404, 429}

@endpoint GET /api/v1/principal-rate-limits/{principalRateLimitId}
@returns(200) {createdBy: str, createdDate: str(date-time), defaultConcurrencyPercentage: int, defaultPercentage: int, id: str, lastUpdate: str(date-time), lastUpdatedBy: str, orgId: str, principalId: str, principalType: str}
@errors {403, 404, 429}

@endpoint PUT /api/v1/principal-rate-limits/{principalRateLimitId}
@required {principalId: str, principalType: str(OAUTH_CLIENT/SSWS_TOKEN)}
@optional {createdBy: str, createdDate: str(date-time), defaultConcurrencyPercentage: int, defaultPercentage: int, id: str, lastUpdate: str(date-time), lastUpdatedBy: str, orgId: str}
@returns(200) {createdBy: str, createdDate: str(date-time), defaultConcurrencyPercentage: int, defaultPercentage: int, id: str, lastUpdate: str(date-time), lastUpdatedBy: str, orgId: str, principalId: str, principalType: str}
@errors {400, 403, 404, 429}

@endpoint GET /api/v1/push-providers
@optional {type: str}
@returns(200)
@errors {403, 429}

@endpoint POST /api/v1/push-providers
@optional {id: str, lastUpdatedDate: str, name: str, providerType: str(APNS/FCM), _links: map{self: any}}
@returns(200) {id: str, lastUpdatedDate: str, name: str, providerType: str, _links: map{self: any}}
@errors {400, 403, 429}

@endpoint GET /api/v1/push-providers/{pushProviderId}
@returns(200) {id: str, lastUpdatedDate: str, name: str, providerType: str, _links: map{self: any}}
@errors {403, 404, 429}

@endpoint PUT /api/v1/push-providers/{pushProviderId}
@optional {id: str, lastUpdatedDate: str, name: str, providerType: str(APNS/FCM), _links: map{self: any}}
@returns(200) {id: str, lastUpdatedDate: str, name: str, providerType: str, _links: map{self: any}}
@errors {400, 403, 404, 429}

@endpoint DELETE /api/v1/push-providers/{pushProviderId}
@returns(204)
@errors {403, 404, 409, 429}

@endpoint GET /api/v1/rate-limit-settings/admin-notifications
@returns(200) {notificationsEnabled: bool}
@errors {403, 429}

@endpoint PUT /api/v1/rate-limit-settings/admin-notifications
@required {notificationsEnabled: bool}
@returns(200) {notificationsEnabled: bool}
@errors {400, 403, 429}

@endpoint GET /api/v1/rate-limit-settings/per-client
@returns(200) {defaultMode: str, useCaseModeOverrides: map{LOGIN_PAGE: str, OAUTH2_AUTHORIZE: str, OIE_APP_INTENT: str}}
@errors {403, 429}

@endpoint PUT /api/v1/rate-limit-settings/per-client
@required {defaultMode: str(DISABLE/ENFORCE/PREVIEW)}
@optional {useCaseModeOverrides: map{LOGIN_PAGE: str, OAUTH2_AUTHORIZE: str, OIE_APP_INTENT: str}}
@returns(200) {defaultMode: str, useCaseModeOverrides: map{LOGIN_PAGE: str, OAUTH2_AUTHORIZE: str, OIE_APP_INTENT: str}}
@errors {400, 403, 429}

@endpoint GET /api/v1/rate-limit-settings/warning-threshold
@returns(200) {warningThreshold: int}
@errors {403, 429}

@endpoint PUT /api/v1/rate-limit-settings/warning-threshold
@required {warningThreshold: int}
@returns(200) {warningThreshold: int}
@errors {400, 403, 429}

@endpoint GET /api/v1/realm-assignments
@optional {limit: int=20, after: str}
@returns(200)
@errors {403, 429}

@endpoint POST /api/v1/realm-assignments
@optional {actions: map{assignUserToRealm: map}, conditions: map{expression: map, profileSourceId: str}, name: str, priority: int}
@returns(201) {actions: map{assignUserToRealm: map{realmId: str}}, conditions: map{expression: map{value: str}, profileSourceId: str}, created: str(date-time), domains: [any], id: str, isDefault: bool, lastUpdated: str(date-time), name: str, priority: int, status: str, _links: map{self: any}}
@errors {400, 403, 429}

@endpoint GET /api/v1/realm-assignments/operations
@optional {limit: int=20, after: str}
@returns(200)
@errors {403, 429}

@endpoint POST /api/v1/realm-assignments/operations
@optional {assignmentId: str}
@returns(201) {assignmentOperation: map{configuration: map{actions: map{assignUserToRealm: map}, conditions: map{expression: map, profileSourceId: str}, id: str, name: str}}, completed: str(date-time), created: str(date-time), id: str, numUserMoved: num, realmId: str, realmName: str, started: str(date-time), status: str, type: str, _links: map{self: any}}
@errors {400, 403, 429}

@endpoint GET /api/v1/realm-assignments/{assignmentId}
@returns(200) {actions: map{assignUserToRealm: map{realmId: str}}, conditions: map{expression: map{value: str}, profileSourceId: str}, created: str(date-time), domains: [any], id: str, isDefault: bool, lastUpdated: str(date-time), name: str, priority: int, status: str, _links: map{self: any}}
@errors {400, 403, 404, 429}

@endpoint PUT /api/v1/realm-assignments/{assignmentId}
@optional {actions: map{assignUserToRealm: map}, conditions: map{expression: map, profileSourceId: str}, name: str, priority: int}
@returns(200) {actions: map{assignUserToRealm: map{realmId: str}}, conditions: map{expression: map{value: str}, profileSourceId: str}, created: str(date-time), domains: [any], id: str, isDefault: bool, lastUpdated: str(date-time), name: str, priority: int, status: str, _links: map{self: any}}
@errors {400, 403, 404, 429}

@endpoint DELETE /api/v1/realm-assignments/{assignmentId}
@returns(204)
@errors {400, 403, 404, 429}

@endpoint POST /api/v1/realm-assignments/{assignmentId}/lifecycle/activate
@returns(204)
@errors {400, 403, 404, 429}

@endpoint POST /api/v1/realm-assignments/{assignmentId}/lifecycle/deactivate
@returns(204)
@errors {400, 403, 404, 429}

@endpoint GET /api/v1/realms
@optional {limit: int(int32)=200, after: str, search: str, sortBy: str, sortOrder: str=asc}
@returns(200)
@errors {403, 429}

@endpoint POST /api/v1/realms
@optional {profile: map{domains: [any], name!: str, realmType: str}}
@returns(200) {created: str(date-time), id: str, isDefault: bool, lastUpdated: str(date-time), profile: map{domains: [any], name: str, realmType: str}, _links: map{self: any}}
@errors {400, 403, 429}

@endpoint GET /api/v1/realms/{realmId}
@returns(200) {created: str(date-time), id: str, isDefault: bool, lastUpdated: str(date-time), profile: map{domains: [any], name: str, realmType: str}, _links: map{self: any}}
@errors {400, 403, 404, 429}

@endpoint PUT /api/v1/realms/{realmId}
@optional {profile: map{domains: [any], name!: str, realmType: str}}
@returns(200) {created: str(date-time), id: str, isDefault: bool, lastUpdated: str(date-time), profile: map{domains: [any], name: str, realmType: str}, _links: map{self: any}}
@errors {400, 403, 404, 429}

@endpoint DELETE /api/v1/realms/{realmId}
@returns(204)
@errors {400, 403, 404, 429}

@endpoint POST /api/v1/risk/events/ip
@returns(202)
@errors {400, 403, 429}

@endpoint GET /api/v1/risk/providers
@returns(200)
@errors {403, 429}

@endpoint POST /api/v1/risk/providers
@required {action: str(enforce_and_log/log_only/none)=log_only, clientId: str, id: str, name: str, _links: map{self: any}}
@optional {created: str(date-time), lastUpdated: str(date-time)}
@returns(201) {action: str, clientId: str, created: str(date-time), id: str, lastUpdated: str(date-time), name: str, _links: map{self: any}}
@errors {400, 403, 429}

@endpoint GET /api/v1/risk/providers/{riskProviderId}
@returns(200) {action: str, clientId: str, created: str(date-time), id: str, lastUpdated: str(date-time), name: str, _links: map{self: any}}
@errors {403, 404, 429}

@endpoint PUT /api/v1/risk/providers/{riskProviderId}
@required {action: str(enforce_and_log/log_only/none)=log_only, clientId: str, id: str, name: str, _links: map{self: any}}
@optional {created: str(date-time), lastUpdated: str(date-time)}
@returns(200) {action: str, clientId: str, created: str(date-time), id: str, lastUpdated: str(date-time), name: str, _links: map{self: any}}
@errors {400, 403, 404, 429}

@endpoint DELETE /api/v1/risk/providers/{riskProviderId}
@returns(204)
@errors {403, 404, 429}

@endpoint GET /api/v1/roles/{roleRef}/subscriptions
@returns(200)
@errors {403, 404, 429}

@endpoint GET /api/v1/roles/{roleRef}/subscriptions/{notificationType}
@returns(200) {channels: [str], notificationType: str, status: str, _links: map{self: map{hints: map{allow: [str]}, href: str, name: str, templated: bool, type: str}}}
@errors {403, 404, 429}

@endpoint POST /api/v1/roles/{roleRef}/subscriptions/{notificationType}/subscribe
@returns(200)
@errors {403, 404, 429}

@endpoint POST /api/v1/roles/{roleRef}/subscriptions/{notificationType}/unsubscribe
@returns(200)
@errors {403, 404, 429}

@endpoint GET /api/v1/security-events-providers
@returns(200)
@errors {401, 403, 429}

@endpoint POST /api/v1/security-events-providers
@required {name: str, settings: map, type: str}
@returns(200) {id: str, name: str, settings: map{issuer: str, jwks_url: str(url), well_known_url: str(url)?}, status: str, type: str, _links: any}
@errors {400, 401, 403, 429}

@endpoint GET /api/v1/security-events-providers/{securityEventProviderId}
@returns(200) {id: str, name: str, settings: map{issuer: str, jwks_url: str(url), well_known_url: str(url)?}, status: str, type: str, _links: any}
@errors {401, 403, 404, 429}

@endpoint PUT /api/v1/security-events-providers/{securityEventProviderId}
@required {name: str, settings: map, type: str}
@returns(200) {id: str, name: str, settings: map{issuer: str, jwks_url: str(url), well_known_url: str(url)?}, status: str, type: str, _links: any}
@errors {400, 401, 403, 404, 429}

@endpoint DELETE /api/v1/security-events-providers/{securityEventProviderId}
@returns(204)
@errors {401, 403, 404, 429}

@endpoint POST /api/v1/security-events-providers/{securityEventProviderId}/lifecycle/activate
@returns(200) {id: str, name: str, settings: map{issuer: str, jwks_url: str(url), well_known_url: str(url)?}, status: str, type: str, _links: any}
@errors {401, 403, 404, 429}

@endpoint POST /api/v1/security-events-providers/{securityEventProviderId}/lifecycle/deactivate
@returns(200) {id: str, name: str, settings: map{issuer: str, jwks_url: str(url), well_known_url: str(url)?}, status: str, type: str, _links: any}
@errors {401, 403, 404, 429}

@endpoint POST /api/v1/sessions
@optional {sessionToken: str}
@returns(200) {amr: [str], createdAt: str(date-time), expiresAt: str(date-time), id: str, idp: map{id: str, type: str}, lastFactorVerification: str(date-time), lastPasswordVerification: str(date-time), login: str, status: str, userId: str, _links: map{self: any}}
@errors {400, 403, 429}

@endpoint GET /api/v1/sessions/me
@optional {Cookie: str}
@returns(200) {amr: [str], createdAt: str(date-time), expiresAt: str(date-time), id: str, idp: map{id: str, type: str}, lastFactorVerification: str(date-time), lastPasswordVerification: str(date-time), login: str, status: str, userId: str, _links: map{self: any}}
@errors {404}

@endpoint DELETE /api/v1/sessions/me
@optional {Cookie: str}
@returns(204)
@errors {404}

@endpoint POST /api/v1/sessions/me/lifecycle/refresh
@optional {Cookie: str}
@returns(200) {amr: [str], createdAt: str(date-time), expiresAt: str(date-time), id: str, idp: map{id: str, type: str}, lastFactorVerification: str(date-time), lastPasswordVerification: str(date-time), login: str, status: str, userId: str, _links: map{self: any}}
@errors {404}

@endpoint GET /api/v1/sessions/{sessionId}
@returns(200) {amr: [str], createdAt: str(date-time), expiresAt: str(date-time), id: str, idp: map{id: str, type: str}, lastFactorVerification: str(date-time), lastPasswordVerification: str(date-time), login: str, status: str, userId: str, _links: map{self: any}}
@errors {400, 403, 404, 429}

@endpoint DELETE /api/v1/sessions/{sessionId}
@returns(204)
@errors {403, 404, 429}

@endpoint POST /api/v1/sessions/{sessionId}/lifecycle/refresh
@returns(200) {amr: [str], createdAt: str(date-time), expiresAt: str(date-time), id: str, idp: map{id: str, type: str}, lastFactorVerification: str(date-time), lastPasswordVerification: str(date-time), login: str, status: str, userId: str, _links: map{self: any}}
@errors {403, 404, 429}

@endpoint GET /api/v1/ssf/stream
@optional {stream_id: str}
@returns(200)
@errors {401, 403, 404, 429}

@endpoint POST /api/v1/ssf/stream
@required {delivery: map{authorization_header: str, endpoint_url!: str(uri), method!: str}, events_requested: [str(uri)]}
@optional {format: str}
@returns(201) {aud: any, delivery: map{authorization_header: str?, endpoint_url: str(uri), method: str}, events_delivered: [str(uri)], events_requested: [str(uri)], events_supported: [str(uri)], format: str, iss: str, min_verification_interval: int?, stream_id: str}
@errors {400, 401, 403, 409, 429}

@endpoint PUT /api/v1/ssf/stream
@required {delivery: map{authorization_header: str, endpoint_url!: str(uri), method!: str}, events_requested: [str(uri)]}
@optional {aud: any, events_delivered: [str(uri)], events_supported: [str(uri)], format: str, iss: str, min_verification_interval: int, stream_id: str}
@returns(200) {aud: any, delivery: map{authorization_header: str?, endpoint_url: str(uri), method: str}, events_delivered: [str(uri)], events_requested: [str(uri)], events_supported: [str(uri)], format: str, iss: str, min_verification_interval: int?, stream_id: str}
@errors {400, 401, 403, 404, 429}

@endpoint PATCH /api/v1/ssf/stream
@required {delivery: map{authorization_header: str, endpoint_url!: str(uri), method!: str}, events_requested: [str(uri)]}
@optional {aud: any, events_delivered: [str(uri)], events_supported: [str(uri)], format: str, iss: str, min_verification_interval: int, stream_id: str}
@returns(200) {aud: any, delivery: map{authorization_header: str?, endpoint_url: str(uri), method: str}, events_delivered: [str(uri)], events_requested: [str(uri)], events_supported: [str(uri)], format: str, iss: str, min_verification_interval: int?, stream_id: str}
@errors {400, 401, 403, 404, 429}

@endpoint DELETE /api/v1/ssf/stream
@optional {stream_id: str}
@returns(204)
@errors {400, 401, 403, 404, 429}

@endpoint GET /api/v1/ssf/stream/status
@required {stream_id: str}
@returns(200) {status: str, stream_id: str}
@errors {400, 401, 403, 404, 429}

@endpoint POST /api/v1/ssf/stream/verification
@required {stream_id: str}
@optional {state: str}
@returns(204)
@errors {400, 401, 403, 404, 429}

@endpoint GET /api/v1/templates/sms
@optional {templateType: str}
@returns(200)
@errors {403, 429}

@endpoint POST /api/v1/templates/sms
@optional {created: str(date-time), id: str, lastUpdated: str(date-time), name: str, template: str, translations: map, type: str}
@returns(200) {created: str(date-time), id: str, lastUpdated: str(date-time), name: str, template: str, translations: map, type: str}
@errors {400, 403, 429}

@endpoint GET /api/v1/templates/sms/{templateId}
@returns(200) {created: str(date-time), id: str, lastUpdated: str(date-time), name: str, template: str, translations: map, type: str}
@errors {403, 404, 429}

@endpoint POST /api/v1/templates/sms/{templateId}
@optional {created: str(date-time), id: str, lastUpdated: str(date-time), name: str, template: str, translations: map, type: str}
@returns(200) {created: str(date-time), id: str, lastUpdated: str(date-time), name: str, template: str, translations: map, type: str}
@errors {400, 403, 404, 429}

@endpoint PUT /api/v1/templates/sms/{templateId}
@optional {created: str(date-time), id: str, lastUpdated: str(date-time), name: str, template: str, translations: map, type: str}
@returns(200) {created: str(date-time), id: str, lastUpdated: str(date-time), name: str, template: str, translations: map, type: str}
@errors {400, 403, 404, 429}

@endpoint DELETE /api/v1/templates/sms/{templateId}
@returns(204)
@errors {403, 404, 429}

@endpoint GET /api/v1/threats/configuration
@returns(200) {action: str, created: str(date-time), excludeZones: [str], lastUpdated: str(date-time), _links: map{self: any}}
@errors {403, 429}

@endpoint POST /api/v1/threats/configuration
@required {action: str(none/audit/block)}
@optional {created: str(date-time), excludeZones: [str], lastUpdated: str(date-time), _links: map{self: any}}
@returns(200) {action: str, created: str(date-time), excludeZones: [str], lastUpdated: str(date-time), _links: map{self: any}}
@errors {400, 403, 429}

@endpoint GET /api/v1/trustedOrigins
@optional {q: str, filter: str, after: str, limit: int(int32)=20}
@returns(200)
@errors {403, 429}

@endpoint POST /api/v1/trustedOrigins
@optional {name: str, origin: str, scopes: [map{allowedOktaApps: [str], type: str}]}
@returns(200) {created: str(date-time), createdBy: str, id: str, lastUpdated: str(date-time), lastUpdatedBy: str, name: str, origin: str, scopes: [map], status: str, _links: any}
@errors {400, 403, 429}

@endpoint GET /api/v1/trustedOrigins/{trustedOriginId}
@returns(200) {created: str(date-time), createdBy: str, id: str, lastUpdated: str(date-time), lastUpdatedBy: str, name: str, origin: str, scopes: [map], status: str, _links: any}
@errors {403, 404, 429}

@endpoint PUT /api/v1/trustedOrigins/{trustedOriginId}
@optional {created: str(date-time), createdBy: str, id: str, lastUpdated: str(date-time), lastUpdatedBy: str, name: str, origin: str, scopes: [map{allowedOktaApps: [str], type: str}], status: str(ACTIVE/INACTIVE), _links: any}
@returns(200) {created: str(date-time), createdBy: str, id: str, lastUpdated: str(date-time), lastUpdatedBy: str, name: str, origin: str, scopes: [map], status: str, _links: any}
@errors {400, 403, 404, 429}

@endpoint DELETE /api/v1/trustedOrigins/{trustedOriginId}
@returns(204)
@errors {403, 404, 429}

@endpoint POST /api/v1/trustedOrigins/{trustedOriginId}/lifecycle/activate
@returns(200) {created: str(date-time), createdBy: str, id: str, lastUpdated: str(date-time), lastUpdatedBy: str, name: str, origin: str, scopes: [map], status: str, _links: any}
@errors {403, 404, 429}

@endpoint POST /api/v1/trustedOrigins/{trustedOriginId}/lifecycle/deactivate
@returns(200) {created: str(date-time), createdBy: str, id: str, lastUpdated: str(date-time), lastUpdatedBy: str, name: str, origin: str, scopes: [map], status: str, _links: any}
@errors {403, 404, 429}

@endpoint GET /api/v1/users
@optional {Content-Type: str, search: str, filter: str, q: str, after: str, limit: int(int32)=200, sortBy: str, sortOrder: str, expand: str}
@returns(200)
@errors {403, 429}

@endpoint POST /api/v1/users
@required {profile: map{city: str, costCenter: str, countryCode: str, department: str, displayName: str, division: str, email: str(email), employeeNumber: str, firstName: str, honorificPrefix: str, honorificSuffix: str, lastName: str, locale: str, login: str, manager: str, managerId: str, middleName: str, mobilePhone: str, nickName: str, organization: str, postalAddress: str, preferredLanguage: str, primaryPhone: str, profileUrl: str, secondEmail: str(email), state: str, streetAddress: str, timezone: str, title: str, userType: str, zipCode: str}}
@optional {activate: bool=true, provider: bool=false, nextLogin: str, credentials: map{password: map, provider: map, recovery_question: map}, groupIds: [str], realmId: str, type: map{id: str}}
@returns(200) {activated: str(date-time)?, created: str(date-time), credentials: map{password: map{hash: map{algorithm: str, digestAlgorithm: str, iterationCount: int, keySize: int, salt: str, saltOrder: str, value: str, workFactor: int}, hook: map{type: str}, value: str(password)}, provider: map{name: str, type: str}, recovery_question: map{answer: str, question: str}}, id: str, lastLogin: str(date-time)?, lastUpdated: str(date-time), passwordChanged: str(date-time)?, profile: map{city: str?, costCenter: str?, countryCode: str?, department: str, displayName: str?, division: str?, email: str(email), employeeNumber: str, firstName: str?, honorificPrefix: str?, honorificSuffix: str?, lastName: str?, locale: str, login: str, manager: str?, managerId: str?, middleName: str?, mobilePhone: str?, nickName: str?, organization: str?, postalAddress: str?, preferredLanguage: str?, primaryPhone: str?, profileUrl: str?, secondEmail: str(email)?, state: str?, streetAddress: str?, timezone: str?, title: str?, userType: str?, zipCode: str?}, realmId: str, status: str, statusChanged: str(date-time)?, transitioningToStatus: str?, type: map{id: str}, _embedded: map, _links: any}
@errors {400, 403, 429}

@endpoint POST /api/v1/users/me/lifecycle/delete_sessions
@optional {keepCurrent: bool=true}
@returns(200)
@errors {403, 404, 429}

@endpoint GET /api/v1/users/{id}
@optional {Content-Type: str, expand: str}
@returns(200)
@errors {403, 404, 429}

@endpoint POST /api/v1/users/{id}
@optional {strict: bool, If-Match: str, credentials: map{password: map, provider: map, recovery_question: map}, profile: map{city: str, costCenter: str, countryCode: str, department: str, displayName: str, division: str, email: str(email), employeeNumber: str, firstName: str, honorificPrefix: str, honorificSuffix: str, lastName: str, locale: str, login: str, manager: str, managerId: str, middleName: str, mobilePhone: str, nickName: str, organization: str, postalAddress: str, preferredLanguage: str, primaryPhone: str, profileUrl: str, secondEmail: str(email), state: str, streetAddress: str, timezone: str, title: str, userType: str, zipCode: str}, realmId: str}
@returns(200) {activated: str(date-time)?, created: str(date-time), credentials: map{password: map{hash: map{algorithm: str, digestAlgorithm: str, iterationCount: int, keySize: int, salt: str, saltOrder: str, value: str, workFactor: int}, hook: map{type: str}, value: str(password)}, provider: map{name: str, type: str}, recovery_question: map{answer: str, question: str}}, id: str, lastLogin: str(date-time)?, lastUpdated: str(date-time), passwordChanged: str(date-time)?, profile: map{city: str?, costCenter: str?, countryCode: str?, department: str, displayName: str?, division: str?, email: str(email), employeeNumber: str, firstName: str?, honorificPrefix: str?, honorificSuffix: str?, lastName: str?, locale: str, login: str, manager: str?, managerId: str?, middleName: str?, mobilePhone: str?, nickName: str?, organization: str?, postalAddress: str?, preferredLanguage: str?, primaryPhone: str?, profileUrl: str?, secondEmail: str(email)?, state: str?, streetAddress: str?, timezone: str?, title: str?, userType: str?, zipCode: str?}, realmId: str, status: str, statusChanged: str(date-time)?, transitioningToStatus: str?, type: map{id: str}, _embedded: map, _links: any}
@errors {400, 403, 404, 429}

@endpoint PUT /api/v1/users/{id}
@optional {strict: bool, If-Match: str, credentials: map{password: map, provider: map, recovery_question: map}, profile: map{city: str, costCenter: str, countryCode: str, department: str, displayName: str, division: str, email: str(email), employeeNumber: str, firstName: str, honorificPrefix: str, honorificSuffix: str, lastName: str, locale: str, login: str, manager: str, managerId: str, middleName: str, mobilePhone: str, nickName: str, organization: str, postalAddress: str, preferredLanguage: str, primaryPhone: str, profileUrl: str, secondEmail: str(email), state: str, streetAddress: str, timezone: str, title: str, userType: str, zipCode: str}, realmId: str}
@returns(200) {activated: str(date-time)?, created: str(date-time), credentials: map{password: map{hash: map{algorithm: str, digestAlgorithm: str, iterationCount: int, keySize: int, salt: str, saltOrder: str, value: str, workFactor: int}, hook: map{type: str}, value: str(password)}, provider: map{name: str, type: str}, recovery_question: map{answer: str, question: str}}, id: str, lastLogin: str(date-time)?, lastUpdated: str(date-time), passwordChanged: str(date-time)?, profile: map{city: str?, costCenter: str?, countryCode: str?, department: str, displayName: str?, division: str?, email: str(email), employeeNumber: str, firstName: str?, honorificPrefix: str?, honorificSuffix: str?, lastName: str?, locale: str, login: str, manager: str?, managerId: str?, middleName: str?, mobilePhone: str?, nickName: str?, organization: str?, postalAddress: str?, preferredLanguage: str?, primaryPhone: str?, profileUrl: str?, secondEmail: str(email)?, state: str?, streetAddress: str?, timezone: str?, title: str?, userType: str?, zipCode: str?}, realmId: str, status: str, statusChanged: str(date-time)?, transitioningToStatus: str?, type: map{id: str}, _embedded: map, _links: any}
@errors {400, 403, 404, 429}

@endpoint DELETE /api/v1/users/{id}
@optional {sendEmail: bool=false, Prefer: str}
@returns(204)
@errors {400, 403, 404, 429}

@endpoint GET /api/v1/users/{id}/appLinks
@returns(200)
@errors {403, 404, 429}

@endpoint GET /api/v1/users/{id}/blocks
@returns(200)
@errors {403, 404, 429}

@endpoint GET /api/v1/users/{id}/groups
@returns(200)
@errors {403, 404, 429}

@endpoint GET /api/v1/users/{id}/idps
@returns(200)
@errors {403, 404, 429}

@endpoint POST /api/v1/users/{id}/lifecycle/activate
@optional {sendEmail: bool=true}
@returns(200) {activationToken: str, activationUrl: str}
@errors {403, 404, 429}

@endpoint POST /api/v1/users/{id}/lifecycle/deactivate
@optional {sendEmail: bool=false, Prefer: str}
@returns(200)
@errors {403, 404, 429}

@endpoint POST /api/v1/users/{id}/lifecycle/expire_password
@returns(200) {activated: str(date-time)?, created: str(date-time), credentials: map{password: map{hash: map{algorithm: str, digestAlgorithm: str, iterationCount: int, keySize: int, salt: str, saltOrder: str, value: str, workFactor: int}, hook: map{type: str}, value: str(password)}, provider: map{name: str, type: str}, recovery_question: map{answer: str, question: str}}, id: str, lastLogin: str(date-time)?, lastUpdated: str(date-time), passwordChanged: str(date-time)?, profile: map{city: str?, costCenter: str?, countryCode: str?, department: str, displayName: str?, division: str?, email: str(email), employeeNumber: str, firstName: str?, honorificPrefix: str?, honorificSuffix: str?, lastName: str?, locale: str, login: str, manager: str?, managerId: str?, middleName: str?, mobilePhone: str?, nickName: str?, organization: str?, postalAddress: str?, preferredLanguage: str?, primaryPhone: str?, profileUrl: str?, secondEmail: str(email)?, state: str?, streetAddress: str?, timezone: str?, title: str?, userType: str?, zipCode: str?}, realmId: str, status: str, statusChanged: str(date-time)?, transitioningToStatus: str?, type: map{id: str}, _embedded: map, _links: any}
@errors {403, 404, 429}

@endpoint POST /api/v1/users/{id}/lifecycle/expire_password_with_temp_password
@optional {revokeSessions: bool=false}
@returns(200) {activated: str(date-time)?, created: str(date-time), credentials: map{password: map{hash: map{algorithm: str, digestAlgorithm: str, iterationCount: int, keySize: int, salt: str, saltOrder: str, value: str, workFactor: int}, hook: map{type: str}, value: str(password)}, provider: map{name: str, type: str}, recovery_question: map{answer: str, question: str}}, id: str, lastLogin: str(date-time)?, lastUpdated: str(date-time), passwordChanged: str(date-time)?, profile: map{city: str?, costCenter: str?, countryCode: str?, department: str, displayName: str?, division: str?, email: str(email), employeeNumber: str, firstName: str?, honorificPrefix: str?, honorificSuffix: str?, lastName: str?, locale: str, login: str, manager: str?, managerId: str?, middleName: str?, mobilePhone: str?, nickName: str?, organization: str?, postalAddress: str?, preferredLanguage: str?, primaryPhone: str?, profileUrl: str?, secondEmail: str(email)?, state: str?, streetAddress: str?, timezone: str?, title: str?, userType: str?, zipCode: str?}, realmId: str, status: str, statusChanged: str(date-time)?, transitioningToStatus: str?, type: map{id: str}, _embedded: map, _links: any}
@errors {403, 404, 429}

@endpoint POST /api/v1/users/{id}/lifecycle/reactivate
@optional {sendEmail: bool=false}
@returns(200) {activationToken: str, activationUrl: str}
@errors {403, 404, 429}

@endpoint POST /api/v1/users/{id}/lifecycle/reset_factors
@returns(200)
@errors {403, 404, 429}

@endpoint POST /api/v1/users/{id}/lifecycle/reset_password
@required {sendEmail: bool}
@optional {revokeSessions: bool=false}
@returns(200) {resetPasswordUrl: str}
@errors {403, 404, 429}

@endpoint POST /api/v1/users/{id}/lifecycle/suspend
@returns(200)
@errors {400, 403, 404, 429}

@endpoint POST /api/v1/users/{id}/lifecycle/unlock
@returns(200)
@errors {403, 404, 429}

@endpoint POST /api/v1/users/{id}/lifecycle/unsuspend
@returns(200)
@errors {400, 403, 404, 429}

@endpoint PUT /api/v1/users/{userIdOrLogin}/linkedObjects/{primaryRelationshipName}/{primaryUserId}
@returns(204)
@errors {403, 404, 429}

@endpoint GET /api/v1/users/{userIdOrLogin}/linkedObjects/{relationshipName}
@returns(200)
@errors {403, 404, 429}

@endpoint DELETE /api/v1/users/{userIdOrLogin}/linkedObjects/{relationshipName}
@returns(204)
@errors {403, 404, 429}

@endpoint GET /api/v1/users/{userId}/authenticator-enrollments
@returns(200) {created: str(date-time), id: str, key: str, lastUpdated: str(date-time), name: str, profile: map{phoneNumber: str}, status: str, type: str, _links: any}
@errors {403, 404, 429}

@endpoint POST /api/v1/users/{userId}/authenticator-enrollments/phone
@required {userId: str, authenticatorId: str, profile: map{phoneNumber!: str}}
@returns(200) {created: str(date-time), id: str, key: str, lastUpdated: str(date-time), name: str, profile: map{phoneNumber: str}, status: str, type: str, _links: any}
@errors {400, 403, 429}

@endpoint POST /api/v1/users/{userId}/authenticator-enrollments/tac
@required {userId: str, authenticatorId: str}
@optional {profile: map{multiUse: bool, ttl: str}}
@returns(200) {created: str(date-time), id: str, key: str, lastUpdated: str(date-time), name: str, nickname: str, profile: map{expiresAt: str(date-time), multiUse: bool, tac: str}, status: str, type: str, _links: any}
@errors {400, 403, 429}

@endpoint GET /api/v1/users/{userId}/authenticator-enrollments/{enrollmentId}
@returns(200) {created: str(date-time), id: str, key: str, lastUpdated: str(date-time), name: str, profile: map{phoneNumber: str}, status: str, type: str, _links: any}
@errors {403, 404, 429}

@endpoint DELETE /api/v1/users/{userId}/authenticator-enrollments/{enrollmentId}
@returns(204)
@errors {403, 404, 429}

@endpoint GET /api/v1/users/{userId}/classification
@returns(200) {lastUpdated: str(date-time), type: str}
@errors {403, 404, 429}

@endpoint PUT /api/v1/users/{userId}/classification
@optional {type: str(LITE/STANDARD)}
@returns(200) {lastUpdated: str(date-time), type: str}
@errors {403, 404, 429}

@endpoint GET /api/v1/users/{userId}/clients
@returns(200)
@errors {403, 404, 429}

@endpoint GET /api/v1/users/{userId}/clients/{clientId}/grants
@optional {expand: str, after: str, limit: int(int32)=20}
@returns(200)
@errors {403, 404, 429}

@endpoint DELETE /api/v1/users/{userId}/clients/{clientId}/grants
@returns(204)
@errors {403, 404, 429}

@endpoint GET /api/v1/users/{userId}/clients/{clientId}/tokens
@optional {expand: str, after: str, limit: int(int32)=20}
@returns(200)
@errors {403, 404, 429}

@endpoint DELETE /api/v1/users/{userId}/clients/{clientId}/tokens
@returns(204)
@errors {403, 404, 429}

@endpoint GET /api/v1/users/{userId}/clients/{clientId}/tokens/{tokenId}
@optional {expand: str}
@returns(200) {clientId: str, created: str(date-time), expiresAt: str(date-time), id: str, issuer: str, lastUpdated: str(date-time), scopes: [str], status: str, userId: str, _embedded: map{scopes: [map]}, _links: any}
@errors {403, 404, 429}

@endpoint DELETE /api/v1/users/{userId}/clients/{clientId}/tokens/{tokenId}
@returns(204)
@errors {403, 404, 429}

@endpoint POST /api/v1/users/{userId}/credentials/change_password
@optional {strict: bool=false, newPassword: map{hash: map, hook: map, value: str(password)}, oldPassword: map{hash: map, hook: map, value: str(password)}, revokeSessions: bool=false}
@returns(200) {password: map{hash: map{algorithm: str, digestAlgorithm: str, iterationCount: int, keySize: int, salt: str, saltOrder: str, value: str, workFactor: int}, hook: map{type: str}, value: str(password)}, provider: map{name: str, type: str}, recovery_question: map{answer: str, question: str}}
@errors {400, 403, 404, 429}

@endpoint POST /api/v1/users/{userId}/credentials/change_recovery_question
@optional {password: map{hash: map, hook: map, value: str(password)}, provider: map{name: str, type: str}, recovery_question: map{answer: str, question: str}}
@returns(200) {password: map{hash: map{algorithm: str, digestAlgorithm: str, iterationCount: int, keySize: int, salt: str, saltOrder: str, value: str, workFactor: int}, hook: map{type: str}, value: str(password)}, provider: map{name: str, type: str}, recovery_question: map{answer: str, question: str}}
@errors {400, 403, 404, 429}

@endpoint POST /api/v1/users/{userId}/credentials/forgot_password
@optional {sendEmail: bool=true}
@returns(200) {resetPasswordUrl: str}
@errors {403, 404, 429}

@endpoint POST /api/v1/users/{userId}/credentials/forgot_password_recovery_question
@optional {sendEmail: bool=true, password: map{hash: map, hook: map, value: str(password)}, provider: map{name: str, type: str}, recovery_question: map{answer: str, question: str}}
@returns(200) {password: map{hash: map{algorithm: str, digestAlgorithm: str, iterationCount: int, keySize: int, salt: str, saltOrder: str, value: str, workFactor: int}, hook: map{type: str}, value: str(password)}, provider: map{name: str, type: str}, recovery_question: map{answer: str, question: str}}
@errors {400, 403, 404, 429}

@endpoint GET /api/v1/users/{userId}/devices
@returns(200)
@errors {400, 403, 429}

@endpoint GET /api/v1/users/{userId}/factors
@returns(200)
@errors {403, 404, 429}

@endpoint POST /api/v1/users/{userId}/factors
@optional {updatePhone: bool=false, templateId: str, tokenLifetimeSeconds: int(int32)=300, activate: bool=false, Accept-Language: str, created: str(date-time), factorType: str(call/email/push/question/signed_nonce/sms/token/token:hardware/token:hotp/token:software:totp/u2f/web/webauthn), id: str, lastUpdated: str(date-time), profile: map, provider: str, status: str(ACTIVE/DISABLED/ENROLLED/EXPIRED/INACTIVE/NOT_SETUP/PENDING_ACTIVATION), vendorName: str, _embedded: map, _links: any}
@returns(200) {created: str(date-time), factorType: str, id: str, lastUpdated: str(date-time), profile: map, provider: str, status: str, vendorName: str, _embedded: map, _links: any}
@errors {400, 403, 404, 429}

@endpoint GET /api/v1/users/{userId}/factors/catalog
@returns(200)
@errors {403, 404, 429}

@endpoint GET /api/v1/users/{userId}/factors/questions
@returns(200)
@errors {403, 404, 429}

@endpoint GET /api/v1/users/{userId}/factors/{factorId}
@returns(200) {created: str(date-time), factorType: str, id: str, lastUpdated: str(date-time), profile: map, provider: str, status: str, vendorName: str, _embedded: map, _links: any}
@errors {403, 404, 429}

@endpoint DELETE /api/v1/users/{userId}/factors/{factorId}
@optional {removeRecoveryEnrollment: bool=false}
@returns(204)
@errors {403, 404, 429}

@endpoint POST /api/v1/users/{userId}/factors/{factorId}/lifecycle/activate
@returns(200) {factorType: str, _links: any}
@errors {400, 403, 404, 429}

@endpoint POST /api/v1/users/{userId}/factors/{factorId}/resend
@optional {templateId: str, factorType: str(call/email/sms)}
@returns(200) {factorType: str}
@errors {400, 403, 404, 429}

@endpoint GET /api/v1/users/{userId}/factors/{factorId}/transactions/{transactionId}
@returns(200) {factorResult: str}
@errors {403, 404, 429}

@endpoint POST /api/v1/users/{userId}/factors/{factorId}/verify
@optional {templateId: str, tokenLifetimeSeconds: int(int32)=300, X-Forwarded-For: str, User-Agent: str, Accept-Language: str}
@returns(200) {expiresAt: str(date-time), factorMessage: str?, factorResult: str, profile: map, _embedded: any, _links: any}
@returns(201) {expiresAt: str(date-time), factorMessage: str?, factorResult: str, profile: map, _embedded: any, _links: any}
@errors {400, 403, 404, 429}

@endpoint GET /api/v1/users/{userId}/grants
@optional {scopeId: str, expand: str, after: str, limit: int(int32)=20}
@returns(200)
@errors {403, 404, 429}

@endpoint DELETE /api/v1/users/{userId}/grants
@returns(204)
@errors {403, 404, 429}

@endpoint GET /api/v1/users/{userId}/grants/{grantId}
@optional {expand: str}
@returns(200) {clientId: str, created: str(date-time), createdBy: map{id: str, type: str}, id: str, issuer: str, lastUpdated: str(date-time), scopeId: str, source: str, status: str, userId: str, _embedded: map{scope: map{id: str}}, _links: any}
@errors {403, 404, 429}

@endpoint DELETE /api/v1/users/{userId}/grants/{grantId}
@returns(204)
@errors {403, 404, 429}

@endpoint GET /api/v1/users/{userId}/risk
@returns(200) {riskLevel: str, _links: any}
@errors {403, 404, 429}

@endpoint PUT /api/v1/users/{userId}/risk
@optional {riskLevel: str(HIGH/LOW)}
@returns(200) {reason: str, riskLevel: str, _links: any}
@returns(201) {reason: str, riskLevel: str, _links: any}
@errors {400, 403, 404, 429}

@endpoint GET /api/v1/users/{userId}/roles
@optional {expand: str}
@returns(200)
@errors {403, 404, 429}

@endpoint POST /api/v1/users/{userId}/roles
@optional {disableNotifications: bool=false}
@returns(201)
@errors {400, 403, 404, 429}

@endpoint GET /api/v1/users/{userId}/roles/{roleAssignmentId}
@returns(200)
@errors {403, 404, 429}

@endpoint DELETE /api/v1/users/{userId}/roles/{roleAssignmentId}
@returns(204)
@errors {403, 404, 429}

@endpoint GET /api/v1/users/{userId}/roles/{roleAssignmentId}/governance
@returns(200) {grants: [map], _links: map{assignee: any, self: any}}
@errors {403, 404, 429}

@endpoint GET /api/v1/users/{userId}/roles/{roleAssignmentId}/governance/{grantId}
@returns(200) {bundleId: str, expirationDate: str(date-time), grantId: str, type: str, _links: any}
@errors {403, 404, 429}

@endpoint GET /api/v1/users/{userId}/roles/{roleAssignmentId}/governance/{grantId}/resources
@returns(200) {resources: [map], _links: any}
@errors {403, 404, 429}

@endpoint GET /api/v1/users/{userId}/roles/{roleAssignmentId}/targets/catalog/apps
@optional {after: str, limit: int=20}
@returns(200)
@errors {403, 404, 429}

@endpoint PUT /api/v1/users/{userId}/roles/{roleAssignmentId}/targets/catalog/apps
@returns(200)
@errors {403, 404, 429}

@endpoint PUT /api/v1/users/{userId}/roles/{roleAssignmentId}/targets/catalog/apps/{appName}
@returns(204)
@errors {403, 404, 429}

@endpoint DELETE /api/v1/users/{userId}/roles/{roleAssignmentId}/targets/catalog/apps/{appName}
@returns(204)
@errors {403, 404, 429}

@endpoint PUT /api/v1/users/{userId}/roles/{roleAssignmentId}/targets/catalog/apps/{appName}/{appId}
@returns(204)
@errors {403, 404, 429}

@endpoint DELETE /api/v1/users/{userId}/roles/{roleAssignmentId}/targets/catalog/apps/{appName}/{appId}
@returns(204)
@errors {403, 404, 429}

@endpoint GET /api/v1/users/{userId}/roles/{roleAssignmentId}/targets/groups
@optional {after: str, limit: int=20}
@returns(200)
@errors {403, 404, 429}

@endpoint PUT /api/v1/users/{userId}/roles/{roleAssignmentId}/targets/groups/{groupId}
@returns(204)
@errors {403, 404, 429}

@endpoint DELETE /api/v1/users/{userId}/roles/{roleAssignmentId}/targets/groups/{groupId}
@returns(204)
@errors {403, 404, 429}

@endpoint GET /api/v1/users/{userId}/roles/{roleIdOrEncodedRoleId}/targets
@optional {assignmentType: str(USER/GROUP), after: str, limit: int=20}
@returns(200)
@errors {403, 404, 429}

@endpoint DELETE /api/v1/users/{userId}/sessions
@optional {oauthTokens: bool=false, forgetDevices: bool=true}
@returns(204)
@errors {403, 404, 429}

@endpoint GET /api/v1/users/{userId}/subscriptions
@required {userId: str}
@returns(200)
@errors {403, 404, 429}

@endpoint GET /api/v1/users/{userId}/subscriptions/{notificationType}
@required {userId: str, notificationType: str}
@returns(200) {channels: [str], notificationType: str, status: str, _links: map{self: map{hints: map{allow: [str]}, href: str, name: str, templated: bool, type: str}}}
@errors {403, 404, 429}

@endpoint POST /api/v1/users/{userId}/subscriptions/{notificationType}/subscribe
@required {userId: str, notificationType: str}
@returns(200)
@errors {403, 404, 429}

@endpoint POST /api/v1/users/{userId}/subscriptions/{notificationType}/unsubscribe
@required {userId: str, notificationType: str}
@returns(200)
@errors {403, 404, 429}

@endpoint GET /api/v1/zones
@optional {after: str, limit: int(int32)=-1, filter: str}
@returns(200)
@errors {403, 429}

@endpoint POST /api/v1/zones
@required {name: str, type: str(DYNAMIC/IP/DYNAMIC_V2)}
@optional {created: str(date-time), id: str, lastUpdated: str(date-time), status: str(ACTIVE/INACTIVE), system: bool, usage: str(BLOCKLIST/POLICY), _links: any}
@returns(200) {created: str(date-time), id: str, lastUpdated: str(date-time), name: str, status: str, system: bool, type: str, usage: str, _links: any}
@errors {400, 403, 429}

@endpoint GET /api/v1/zones/{zoneId}
@returns(200) {created: str(date-time), id: str, lastUpdated: str(date-time), name: str, status: str, system: bool, type: str, usage: str, _links: any}
@errors {403, 404, 429}

@endpoint PUT /api/v1/zones/{zoneId}
@required {name: str, type: str(DYNAMIC/IP/DYNAMIC_V2)}
@optional {created: str(date-time), id: str, lastUpdated: str(date-time), status: str(ACTIVE/INACTIVE), system: bool, usage: str(BLOCKLIST/POLICY), _links: any}
@returns(200) {created: str(date-time), id: str, lastUpdated: str(date-time), name: str, status: str, system: bool, type: str, usage: str, _links: any}
@errors {400, 403, 404, 429}

@endpoint DELETE /api/v1/zones/{zoneId}
@returns(204)
@errors {403, 404, 429}

@endpoint POST /api/v1/zones/{zoneId}/lifecycle/activate
@returns(200) {created: str(date-time), id: str, lastUpdated: str(date-time), name: str, status: str, system: bool, type: str, usage: str, _links: any}
@errors {403, 404, 429}

@endpoint POST /api/v1/zones/{zoneId}/lifecycle/deactivate
@returns(200) {created: str(date-time), id: str, lastUpdated: str(date-time), name: str, status: str, system: bool, type: str, usage: str, _links: any}
@errors {403, 404, 429}

@endgroup

@group attack-protection
@endpoint GET /attack-protection/api/v1/authenticator-settings
@returns(200)
@errors {403, 429}

@endpoint PUT /attack-protection/api/v1/authenticator-settings
@optional {verifyKnowledgeSecondWhen2faRequired: bool=false}
@returns(200) {verifyKnowledgeSecondWhen2faRequired: bool}
@errors {400, 403, 429}

@endpoint GET /attack-protection/api/v1/user-lockout-settings
@returns(200)
@errors {403, 429}

@endpoint PUT /attack-protection/api/v1/user-lockout-settings
@optional {preventBruteForceLockoutFromUnknownDevices: bool=false}
@returns(200) {preventBruteForceLockoutFromUnknownDevices: bool}
@errors {400, 403, 429}

@endgroup

@group device-access
@endpoint GET /device-access/api/v1/desktop-mfa/enforce-number-matching-challenge-settings
@returns(200) {desktopMFAEnforceNumberMatchingChallengeEnabled: bool}
@errors {403, 429}

@endpoint PUT /device-access/api/v1/desktop-mfa/enforce-number-matching-challenge-settings
@optional {desktopMFAEnforceNumberMatchingChallengeEnabled: bool=false}
@returns(200) {desktopMFAEnforceNumberMatchingChallengeEnabled: bool}
@errors {400, 403, 429}

@endpoint GET /device-access/api/v1/desktop-mfa/recovery-pin-settings
@returns(200) {desktopMFARecoveryPinEnabled: bool}
@errors {403, 429}

@endpoint PUT /device-access/api/v1/desktop-mfa/recovery-pin-settings
@optional {desktopMFARecoveryPinEnabled: bool=false}
@returns(200) {desktopMFARecoveryPinEnabled: bool}
@errors {400, 403, 429}

@endgroup

@group integrations
@endpoint GET /integrations/api/v1/api-services
@optional {after: str}
@returns(200)
@errors {401, 403, 429}

@endpoint POST /integrations/api/v1/api-services
@required {grantedScopes: [str], type: str}
@optional {properties: map}
@returns(201)
@errors {400, 401, 403, 429}

@endpoint GET /integrations/api/v1/api-services/{apiServiceId}
@returns(200) {configGuideUrl: str, createdAt: str, createdBy: str, grantedScopes: [str], id: str, name: str, properties: map, type: str, _links: any}
@errors {401, 403, 404, 429}

@endpoint DELETE /integrations/api/v1/api-services/{apiServiceId}
@returns(204)
@errors {401, 403, 404, 429}

@endpoint GET /integrations/api/v1/api-services/{apiServiceId}/credentials/secrets
@returns(200)
@errors {401, 403, 404, 429}

@endpoint POST /integrations/api/v1/api-services/{apiServiceId}/credentials/secrets
@returns(201) {client_secret: str, created: str, id: str, lastUpdated: str, secret_hash: str, status: str, _links: any}
@errors {400, 401, 403, 429}

@endpoint DELETE /integrations/api/v1/api-services/{apiServiceId}/credentials/secrets/{secretId}
@returns(204)
@errors {401, 403, 404, 429}

@endpoint POST /integrations/api/v1/api-services/{apiServiceId}/credentials/secrets/{secretId}/lifecycle/activate
@returns(200) {client_secret: str, created: str, id: str, lastUpdated: str, secret_hash: str, status: str, _links: any}
@errors {401, 403, 404, 429}

@endpoint POST /integrations/api/v1/api-services/{apiServiceId}/credentials/secrets/{secretId}/lifecycle/deactivate
@returns(200) {client_secret: str, created: str, id: str, lastUpdated: str, secret_hash: str, status: str, _links: any}
@errors {401, 403, 404, 429}

@endgroup

@group oauth2
@endpoint GET /oauth2/v1/clients/{clientId}/roles
@returns(200)
@errors {403, 404, 429}

@endpoint POST /oauth2/v1/clients/{clientId}/roles
@returns(200)
@errors {403, 404, 429}

@endpoint GET /oauth2/v1/clients/{clientId}/roles/{roleAssignmentId}
@returns(200)
@errors {403, 404, 429}

@endpoint DELETE /oauth2/v1/clients/{clientId}/roles/{roleAssignmentId}
@returns(204)
@errors {403, 404, 429}

@endpoint GET /oauth2/v1/clients/{clientId}/roles/{roleAssignmentId}/targets/catalog/apps
@optional {after: str, limit: int=20}
@returns(200)
@errors {403, 404, 429}

@endpoint PUT /oauth2/v1/clients/{clientId}/roles/{roleAssignmentId}/targets/catalog/apps/{appName}
@returns(204)
@errors {403, 404, 429}

@endpoint DELETE /oauth2/v1/clients/{clientId}/roles/{roleAssignmentId}/targets/catalog/apps/{appName}
@returns(204)
@errors {403, 404, 429}

@endpoint PUT /oauth2/v1/clients/{clientId}/roles/{roleAssignmentId}/targets/catalog/apps/{appName}/{appId}
@returns(204)
@errors {403, 404, 429}

@endpoint DELETE /oauth2/v1/clients/{clientId}/roles/{roleAssignmentId}/targets/catalog/apps/{appName}/{appId}
@returns(204)
@errors {403, 404, 429}

@endpoint GET /oauth2/v1/clients/{clientId}/roles/{roleAssignmentId}/targets/groups
@optional {after: str, limit: int=20}
@returns(200)
@errors {403, 404, 429}

@endpoint PUT /oauth2/v1/clients/{clientId}/roles/{roleAssignmentId}/targets/groups/{groupId}
@returns(204)
@errors {403, 404, 429}

@endpoint DELETE /oauth2/v1/clients/{clientId}/roles/{roleAssignmentId}/targets/groups/{groupId}
@returns(204)
@errors {403, 404, 429}

@endgroup

@group okta-personal-settings
@endpoint PUT /okta-personal-settings/api/v1/edit-feature
@optional {enableEnduserEntryPoints: bool, enableExportApps: bool}
@returns(204)
@errors {401, 403, 404, 429}

@endpoint GET /okta-personal-settings/api/v1/export-blocklists
@returns(200) {domains: [any]}
@errors {401, 403, 404, 429}

@endpoint PUT /okta-personal-settings/api/v1/export-blocklists
@optional {domains: [any]}
@returns(204)
@errors {401, 403, 404, 429}

@endgroup

@group privileged-access
@endpoint GET /privileged-access/api/v1/service-accounts
@optional {limit: int=20, after: str, match: str}
@returns(200)
@errors {400, 403, 404, 429}

@endpoint POST /privileged-access/api/v1/service-accounts
@required {containerOrn: str, name: str(regex), username: str}
@optional {containerGlobalName: str, containerInstanceName: str, created: str(date-time), description: str(regex), id: str(regex), lastUpdated: str(date-time), ownerGroupIds: [str], ownerUserIds: [str], password: str(password), status: str(ALERT/ERROR/INFO/NO_ISSUES/UNSECURED), statusDetail: str(CREATION_FAILED/MISSING_PASSWORD/PENDING/ROTATED/ROTATING/ROTATION_FAILED/STAGED/VAULTED)}
@returns(200) {containerGlobalName: str, containerInstanceName: str, containerOrn: str, created: str(date-time), description: str(regex), id: str(regex), lastUpdated: str(date-time), name: str(regex), ownerGroupIds: [str], ownerUserIds: [str], password: str(password), status: str, statusDetail: str, username: str}
@errors {400, 403, 404, 429}

@endpoint GET /privileged-access/api/v1/service-accounts/{id}
@returns(200) {containerGlobalName: str, containerInstanceName: str, containerOrn: str, created: str(date-time), description: str(regex), id: str(regex), lastUpdated: str(date-time), name: str(regex), ownerGroupIds: [str], ownerUserIds: [str], password: str(password), status: str, statusDetail: str, username: str}
@errors {400, 403, 404, 429}

@endpoint PATCH /privileged-access/api/v1/service-accounts/{id}
@optional {description: str(regex), name: str(regex), ownerGroupIds: [str], ownerUserIds: [str]}
@returns(200) {containerGlobalName: str, containerInstanceName: str, containerOrn: str, created: str(date-time), description: str(regex), id: str(regex), lastUpdated: str(date-time), name: str(regex), ownerGroupIds: [str], ownerUserIds: [str], password: str(password), status: str, statusDetail: str, username: str}
@errors {400, 403, 404, 429}

@endpoint DELETE /privileged-access/api/v1/service-accounts/{id}
@returns(204)
@errors {400, 403, 404, 429}

@endgroup

@group security
@endpoint POST /security/api/v1/security-events
@returns(202)
@errors {400}

@endgroup

@group webauthn-registration
@endpoint POST /webauthn-registration/api/v1/activate
@optional {credResponses: [map{authenticatorEnrollmentId: str, credResponseJwe: str}], fulfillmentProvider: str, pinResponseJwe: str, serial: str, userId: str, version: str, yubicoSigningJwks: [map{crv!: str, kid!: str, kty!: str, use!: str, x!: str, y!: str}]}
@returns(200) {authenticatorEnrollmentIds: [str], fulfillmentProvider: str, userId: str}
@errors {400, 403, 404, 429}

@endpoint POST /webauthn-registration/api/v1/enroll
@optional {enrollmentRpIds: [str], fulfillmentProvider: str, userId: str, yubicoTransportKeyJWK: map{crv!: str, kid!: str, kty!: str, use!: str, x!: str, y!: str}}
@returns(200) {credRequests: [map], fulfillmentProvider: str, pinRequestJwe: str, userId: str}
@errors {400, 403, 404, 429}

@endpoint POST /webauthn-registration/api/v1/initiate-fulfillment-request
@optional {fulfillmentData: [map{customizationId: str, inventoryProductId: str, productId: str}], fulfillmentProvider: str, userId: str}
@returns(204)
@errors {403, 404, 429}

@endpoint POST /webauthn-registration/api/v1/send-pin
@optional {authenticatorEnrollmentId: str, fulfillmentProvider: str, userId: str}
@returns(204)
@errors {403, 404, 429}

@endpoint GET /webauthn-registration/api/v1/users/{userId}/enrollments
@returns(200)
@errors {403, 404, 429}

@endpoint DELETE /webauthn-registration/api/v1/users/{userId}/enrollments/{authenticatorEnrollmentId}
@returns(204)
@errors {403, 404, 429}

@endpoint POST /webauthn-registration/api/v1/users/{userId}/enrollments/{authenticatorEnrollmentId}/mark-error
@returns(204)
@errors {403, 404, 429}

@endgroup

@end