declare module "scimmy/types" { import SCIMMY from "scimmy"; import Attribute = SCIMMY.Types.Attribute; import SCIMError = SCIMMY.Types.SCIMError; import Filter = SCIMMY.Types.Filter; import SchemaDefinition = SCIMMY.Types.SchemaDefinition; import Schema = SCIMMY.Types.Schema; import Resource = SCIMMY.Types.Resource; export { Attribute, SCIMError, Filter, SchemaDefinition, Schema, Resource }; export default SCIMMY.Types; } declare module "scimmy/schemas" { import SCIMMY from "scimmy"; import User = SCIMMY.Schemas.User; import Group = SCIMMY.Schemas.Group; import EnterpriseUser = SCIMMY.Schemas.EnterpriseUser; import ResourceType = SCIMMY.Schemas.ResourceType; import ServiceProviderConfig = SCIMMY.Schemas.ServiceProviderConfig; export { User, Group, EnterpriseUser, ResourceType, ServiceProviderConfig }; export default SCIMMY.Schemas; } declare module "scimmy/config" { import SCIMMY from "scimmy"; export default SCIMMY.Config; } declare module "scimmy/resources" { import SCIMMY from "scimmy"; import User = SCIMMY.Resources.User; import Group = SCIMMY.Resources.Group; import Schema = SCIMMY.Resources.Schema; import ResourceType = SCIMMY.Resources.ResourceType; import ServiceProviderConfig = SCIMMY.Resources.ServiceProviderConfig; export { User, Group, Schema, ResourceType, ServiceProviderConfig }; export default SCIMMY.Resources; } declare module "scimmy/messages" { import SCIMMY from "scimmy"; import ErrorResponse = SCIMMY.Messages.ErrorResponse; import ListResponse = SCIMMY.Messages.ListResponse; import PatchOp = SCIMMY.Messages.PatchOp; import BulkResponse = SCIMMY.Messages.BulkResponse; import BulkRequest = SCIMMY.Messages.BulkRequest; import SearchRequest = SCIMMY.Messages.SearchRequest; export { ErrorResponse, ListResponse, PatchOp, BulkResponse, BulkRequest, SearchRequest }; export default SCIMMY.Messages; } declare module "scimmy" { import Types = SCIMMY.Types; import Messages = SCIMMY.Messages; import Schemas = SCIMMY.Schemas; import Resources = SCIMMY.Resources; import Config = SCIMMY.Config; export { Types, Messages, Schemas, Resources, Config }; export default SCIMMY; export namespace SCIMMY { export class Types { static Error: typeof SCIMMY.Types.SCIMError; } export namespace Types { export class Attribute { /** * The data type of the attribute */ type: SCIMMY.Types.Attribute.ValidAttributeTypes; /** * The actual name of the attribute */ name: string; /** * Additional config defining the attribute's characteristics */ config: SCIMMY.Types.Attribute.AttributeConfig; /** * If the attribute is complex, the sub-attributes of the attribute */ subAttributes?: SCIMMY.Types.Attribute[]; /** * Constructs an instance of a full SCIM attribute definition * @param type The data type of the attribute * @param name The actual name of the attribute * @param config Additional config defining the attribute's characteristics * @param subAttributes If the attribute is complex, the sub-attributes of the attribute */ constructor(type: SCIMMY.Types.Attribute.ValidAttributeTypes, name: string, config?: SCIMMY.Types.Attribute.AttributeConfig, subAttributes?: SCIMMY.Types.Attribute[]); /** * Remove a subAttribute from a complex attribute definition * @param subAttributes The child attributes to remove from the complex attribute definition * @returns This attribute instance for chaining */ truncate(subAttributes: string | SCIMMY.Types.Attribute): SCIMMY.Types.Attribute; /** * Parse this Attribute instance into a valid SCIM attribute definition object * @returns An object representing a valid SCIM attribute definition */ toJSON(): SCIMMY.Types.Attribute.AttributeDefinition; /** * Coerce a given value by making sure it conforms to attribute's characteristics * @param source Value to coerce and confirm conformity with attribute's characteristics * @param direction Whether to check for inbound, outbound, or bidirectional attributes * @param isComplexMultiValue Indicates whether a coercion is for a single complex value in a collection of complex values * @returns The coerced value, conforming to attribute's characteristics */ coerce(source: any | any[], direction?: string, isComplexMultiValue?: boolean): any; } export namespace Attribute { /** * SCIMMY Attribute Instance Configuration properties */ export type AttributeConfig = { /** * Does the attribute expect a collection of values */ multiValued?: boolean; /** * A human-readable description of the attribute */ description?: string; /** * Whether the attribute is required for the type instance to be valid */ required?: boolean; /** * Values the attribute's contents must be set to */ canonicalValues?: boolean | string[]; /** * Whether the attribute's contents is case-sensitive */ caseExact?: boolean; /** * Whether the attribute's contents is modifiable */ mutable?: boolean | string; /** * Whether the attribute is returned in a response */ returned?: boolean | string; /** * List of referenced types if attribute type is reference */ referenceTypes?: boolean | string[]; /** * The attribute's uniqueness characteristic */ uniqueness?: string | boolean; /** * Whether the attribute should be present for inbound, outbound, or bidirectional requests */ direction?: string; /** * Whether the attribute should be hidden from schemas presented by the resource type endpoint */ shadow?: boolean; }; /** * Collection of valid attribute type characteristic's values */ export type ValidAttributeTypes = "string" | "complex" | "boolean" | "binary" | "decimal" | "integer" | "dateTime" | "reference"; /** * Collection of valid attribute mutability characteristic's values */ export type ValidMutabilityValues = "readOnly" | "readWrite" | "immutable" | "writeOnly"; /** * Collection of valid attribute returned characteristic's values */ export type ValidReturnedValues = "always" | "never" | "default" | "request"; /** * Collection of valid attribute uniqueness characteristic's values */ export type ValidUniquenessValues = "none" | "server" | "global"; /** * SCIM Attribute Definition properties */ export type AttributeDefinition = { /** * The attribute's name */ name: string; /** * The attribute's data type */ type: SCIMMY.Types.Attribute.ValidAttributeTypes; /** * Specifies a SCIM resourceType that a reference attribute may refer to */ referenceTypes?: string[]; /** * Boolean value indicating an attribute's plurality */ multiValued: boolean; /** * A human-readable description of the attribute */ description: string; /** * Boolean value indicating whether the attribute is required */ required: boolean; /** * Defines the sub-attributes of a complex attribute */ subAttributes?: SCIMMY.Types.Attribute.AttributeDefinition[]; /** * Boolean value indicating whether a string attribute is case-sensitive */ caseExact?: boolean; /** * Collection of canonical values */ canonicalValues?: string[]; /** * Indicates whether an attribute is modifiable */ mutability: string; /** * Indicates when an attribute is returned in a response */ returned: string; /** * Indicates how unique a value must be */ uniqueness?: string; }; } export class SCIMError extends Error { /** * HTTP status code to be sent with the error */ status: number; /** * The SCIM detail error keyword as per [RFC7644§3.12]{@link https://datatracker.ietf.org/doc/html/rfc7644.section-3.12} */ scimType: string; /** * A human-readable description of what caused the error to occur */ message: string; /** * Instantiate a new error with SCIM error details * @param status HTTP status code to be sent with the error * @param scimType The SCIM detail error keyword as per [RFC7644§3.12]{@link https://datatracker.ietf.org/doc/html/rfc7644.section-3.12} * @param message A human-readable description of what caused the error to occur */ constructor(status: number, scimType: string, message: string); } export class Filter extends Array { /** * The original string that was parsed by the filter, or the stringified representation of filter expression objects */ expression: string; /** * Instantiate and parse a new SCIM filter string or expression * @param expression The query string to parse, or an existing filter expression object or set of objects */ constructor(expression: string | any | any[]); /** * Compare and filter a given set of values against this filter instance * @param values Values to evaluate filters against * @returns Subset of values that match any expressions of this filter instance */ match(values: any[]): any[]; } export namespace Filter { /** * Collection of valid logical operator strings in a filter expression */ export type ValidLogicStrings = "and" | "or" | "not"; /** * Collection of valid comparison operator strings in a filter expression */ export type ValidComparisonStrings = "eq" | "ne" | "co" | "sw" | "ew" | "gt" | "lt" | "ge" | "le" | "pr" | "np"; } export class SchemaDefinition { /** * Friendly name of the SCIM schema */ name: string; /** * URN namespace of the SCIM schema */ id: string; /** * Human-readable description of the schema */ description: string; /** * Attributes that make up the schema */ attributes: SCIMMY.Types.Attribute[]; /** * Constructs an instance of a full SCIM schema definition * @param name Friendly name of the SCIM schema * @param id URN namespace of the SCIM schema * @param description A human-readable description of the schema * @param attributes Attributes that make up the schema */ constructor(name: string, id: string, description?: string, attributes?: SCIMMY.Types.Attribute[]); /** * Get the SCIM schema definition for consumption by clients * @param basepath The base path for the schema's meta.location property * @returns The schema definition for consumption by clients */ describe(basepath?: string): SCIMMY.Types.SchemaDefinition.SchemaDescription; /** * Find an attribute or extension instance belonging to the schema definition by its name * @param name The name of the attribute to look for (namespaced or direct) * @returns The Attribute or SchemaDefinition instance with matching name */ attribute(name: string): T; /** * Extend a schema definition instance by mixing in other schemas or attributes * @param extension The schema extension or collection of attributes to register * @param required If the extension is a schema, whether the extension is required * @returns This schema definition instance for chaining */ extend(extension: SCIMMY.Types.SchemaDefinition | SCIMMY.Types.Attribute[], required?: boolean): SCIMMY.Types.SchemaDefinition; /** * Remove an attribute, extension schema, or subAttribute from a schema or attribute definition * @param target The name, or names, of attributes to remove from the schema definition * @param target The attribute instance, or instances, to remove from the schema definition * @param target The extension schema, or schemas, to remove from the schema definition * @returns This schema definition instance for chaining */ truncate(...target: Array): SCIMMY.Types.SchemaDefinition; /** * Coerce a given value by making sure it conforms to all schema attributes' characteristics * @param data Value to coerce and confirm conformity of properties to schema attributes' characteristics * @param direction Whether to check for inbound, outbound, or bidirectional attributes * @param basepath The URI representing the resource type's location * @param filter The attribute filters to apply to the coerced value * @returns The coerced value, conforming to all schema attributes' characteristics */ coerce(data: any, direction?: string, basepath?: string, filter?: SCIMMY.Types.Filter): any; } export namespace SchemaDefinition { export type SchemaDescription = { /** * URN namespaces that identify the type of resource being described */ schemas: string[]; /** * URN namespace of the SCIM schema definition */ id: string; /** * Friendly name of the SCIM schema definition */ name: string; /** * Human-readable description of the SCIM schema definition */ description: string; /** * Attributes that make up this schema */ attributes: SCIMMY.Types.Attribute.AttributeDefinition[]; /** * Metadata details of this schema */ meta: { /** * Identifies the type of resource being described */ resourceType: string; /** * Canonical location of this resource */ location: string; }; }; } export class Schema { /** * SCIM schema URN namespace */ static readonly id: string; /** * Retrieves a schema's definition instance */ static readonly definition: SCIMMY.Types.SchemaDefinition; /** * Extend a schema by mixing in other schemas or attributes * @param extension The schema extensions or collection of attributes to register * @param required If the extension is a schema, whether the extension is required */ static extend(extension: SCIMMY.Types.Schema | SCIMMY.Types.Attribute[], required?: boolean): void; /** * Remove an attribute, schema extension, or subAttribute from the schema's definition * @param attributes The child attributes to remove from the schema definition */ static truncate(attributes: SCIMMY.Types.Schema | string | SCIMMY.Types.Attribute | string[] | SCIMMY.Types.Attribute[]): void; /** * Unique identifier for a SCIM resource as defined by the service provider */ id: string; /** * Namespace URIs of the SCIM schemas that define the attributes present in the current data structure */ schemas: string[]; /** * Identifier for the resource as defined by the provisioning client */ externalId?: string; /** * A complex attribute containing resource metadata */ meta: { /** * Name of the resource type of the resource */ resourceType: string; /** * When the resource was added to the service provider */ created?: Date; /** * When this resource was last updated at the service provider */ lastModified?: Date; /** * Full, canonical URI of the resource being returned */ location: string; /** * Version of the resource being returned, if any */ version?: string; }; /** * Construct a resource instance after verifying schema compatibility * @param data The source data to feed through the schema definition * @param direction Whether the resource is inbound from a request or outbound for a response */ constructor(data: any, direction?: string); } export namespace Schema { /** * Automatically assigned attributes not required in schema extension values */ export type ShadowAttributes = "id" | "schemas" | "meta"; /** * A schema instance type with an added schema extension */ export type Extended as `${E[K]}`]?: Omit, Schema.ShadowAttributes>; }> = V; } export class Resource { /** * Retrieves a resource's endpoint relative to the service provider's base URL */ static readonly endpoint: string; /** * Sets or retrieves the base path for resolution of a resource's location * @param path The path to use as the base of a resource's location * @returns This resource type class for chaining if path is a string, or the resource's basepath */ static basepath: Resource.basepath; /** * Retrieves a resource's core schema */ static readonly schema: typeof SCIMMY.Types.Schema; /** * Register an extension to the resource's core schema * @param extension The schema extension to register * @param required Whether the extension is required * @returns This resource type implementation for chaining */ static extend: Resource.extend; /** * Sets the method to be called to consume a resource on create * @param handler Function to invoke to consume a resource on create * @returns This resource type class for chaining */ static ingress: Resource.ingress; /** * Sets the method to be called to retrieve a resource on read * @param handler Function to invoke to retrieve a resource on read * @returns This resource type class for chaining */ static egress: Resource.egress; /** * Sets the method to be called to dispose of a resource on delete * @param handler Function to invoke to dispose of a resource on delete * @returns This resource type class for chaining */ static degress: Resource.degress; /** * Describe this resource type implementation * @returns Object describing the resource type implementation */ static describe(): SCIMMY.Types.Resource.ResourceDescription; /** * ID of the resource instance being targeted */ id?: string; /** * Filter parsed from the supplied config */ filter?: SCIMMY.Types.Filter; /** * Attributes or excluded attributes parsed from the supplied config */ attributes?: SCIMMY.Types.Filter; /** * Sort and pagination properties parsed from the supplied config */ constraints?: SCIMMY.Messages.ListResponse.ListConstraints & { /** * The attribute retrieved resources should be sorted by */ sortBy?: string; /** * The direction retrieved resources should be sorted in */ sortOrder?: string; /** * Offset index that retrieved resources should start from */ startIndex?: number; /** * Maximum number of retrieved resources that should be returned in one operation */ count?: number; }; /** * Instantiate a new SCIM resource and parse any supplied parameters * @param id The ID of the requested resource * @param config The parameters of the resource instance request * @param config.filter The filter to be applied on ingress/egress by implementing resource * @param config.excludedAttributes The comma-separated string list of attributes or filters to exclude on egress * @param config.attributes The comma-separated string list of attributes or filters to include on egress * @param config.sortBy The attribute retrieved resources should be sorted by * @param config.sortOrder The direction retrieved resources should be sorted in * @param config.startIndex Offset index that retrieved resources should start from * @param config.count Maximum number of retrieved resources that should be returned in one operation */ constructor(id?: string, config?: { filter?: string; excludedAttributes?: string; attributes?: string; sortBy?: string; sortOrder?: string; startIndex?: number; count?: number; }); /** * Calls resource's egress method for data retrieval. * Wraps the results in valid SCIM list response or single resource syntax. * @param ctx Any additional context information to pass to the egress handler * @returns The specifically requested resource instance, if an ID was supplied to resource constructor, or collection of resources matching instance's configured filter. */ read(ctx?: T): Promise; /** * Calls resource's ingress method for consumption after unwrapping the SCIM resource * @param instance The raw resource type instance for consumption by ingress method * @param ctx Any additional context information to pass to the ingress handler * @returns The consumed resource type instance */ write(instance: any, ctx?: T): Promise; /** * Retrieves resources via egress method, and applies specified patch operations. * Emits patched resources for consumption with resource's ingress method. * @param message The PatchOp message to apply to the received resource * @param message.schemas List exclusively containing SCIM PatchOp message schema ID * @param message.Operations PatchOp operations to be applied * @param ctx Any additional context information to pass to the ingress/egress handlers * @returns The resource type instance after patching and consumption by ingress method */ patch(message: { schemas: (typeof SCIMMY.Messages.PatchOp.id)[]; Operations: SCIMMY.Messages.PatchOp.PatchOpOperation[]; }, ctx?: T): Promise; /** * Calls resource's degress method for disposal of the SCIM resource * @param ctx Any additional context information to pass to the degress handler */ dispose(ctx?: T): Promise; } export namespace Resource { /** * Automatically assigned attributes not required in handler return values */ export type ShadowAttributes = "schemas" | "meta"; /** * Sets or retrieves the base path for resolution of a resource's location * @param path The path to use as the base of a resource's location * @returns This resource type class for chaining if path is a string, or the resource's basepath */ type basepath> = (path?: string) => string | R; /** * Register an extension to the resource's core schema * @param extension The schema extension to register * @param required Whether the extension is required * @returns This resource type implementation for chaining */ type extend, S extends SCIMMY.Types.Schema = any> = (extension: typeof SCIMMY.Types.Schema, required?: boolean) => R; /** * Handler for ingress of a resource * @param resource The resource performing the ingress * @param instance An instance of the resource type that conforms to the resource's schema * @param ctx External context in which the handler has been called * @returns An object to be used to create a new schema instance, whose properties conform to the resource type's schema */ export type IngressHandler, S extends SCIMMY.Types.Schema, V extends Record = Omit, Resource.ShadowAttributes>> = (resource: R, instance: S, ctx?: any) => V | Promise; /** * Sets the method to be called to consume a resource on create * @param handler Function to invoke to consume a resource on create * @returns This resource type class for chaining */ type ingress, S extends SCIMMY.Types.Schema> = (handler: SCIMMY.Types.Resource.IngressHandler, V>) => R; /** * Handler for egress of a resource * @param resource The resource performing the egress * @param ctx External context in which the handler has been called * @returns An object, or array of objects, to be used to create a new schema instances, whose properties conform to the resource type's schema */ export type EgressHandler, S extends SCIMMY.Types.Schema, V extends Record = Omit, Resource.ShadowAttributes>> = (resource: R, ctx?: any) => V | V[] | Promise; /** * Sets the method to be called to retrieve a resource on read * @param handler Function to invoke to retrieve a resource on read * @returns This resource type class for chaining */ type egress, S extends SCIMMY.Types.Schema> = (handler: SCIMMY.Types.Resource.EgressHandler, V>) => R; /** * Handler for degress of a resource * @param resource The resource performing the degress * @param ctx External context in which the handler has been called */ export type DegressHandler> = (resource: R, ctx?: any) => void | Promise; /** * Sets the method to be called to dispose of a resource on delete * @param handler Function to invoke to dispose of a resource on delete * @returns This resource type class for chaining */ type degress> = (handler: SCIMMY.Types.Resource.DegressHandler>) => R; /** * An object describing a resource type's implementation */ export type ResourceDescription = { /** * URN namespace of the resource's SCIM schema definition */ id: string; /** * Friendly name of the resource's SCIM schema definition */ name: string; /** * Resource type's endpoint, relative to a service provider's base URL */ endpoint: string; /** * Human-readable description of the resource */ description: string; /** * Schema extensions that augment the resource */ schemaExtensions?: Array<{ /** * URN namespace of the schema extension that augments the resource */ schema: string; /** * Whether resource instances must include the schema extension */ required: boolean; }>; }; } } export class Messages { static Error: typeof SCIMMY.Messages.ErrorResponse; } export namespace Messages { export class ErrorResponse extends Error { /** * SCIM Error Message Schema ID */ static readonly id: "urn:ietf:params:scim:api:messages:2.0:Error"; /** * List exclusively containing the SCIM Error message schema ID */ schemas: [typeof SCIMMY.Messages.ErrorResponse.id]; /** * Stringified HTTP status code to be sent with the error */ status: SCIMMY.Messages.ErrorResponse.ValidStatusCodes; /** * The SCIM detail error keyword as per [RFC7644§3.12]{@link https://datatracker.ietf.org/doc/html/rfc7644.section-3.12} */ scimType?: SCIMMY.Messages.ErrorResponse.ValidScimTypes; /** * A human-readable description of what caused the error to occur */ detail?: string; /** * Instantiate a new SCIM Error Message with relevant details * @param ex The initiating exception to parse into a SCIM error message */ constructor(ex?: typeof SCIMMY.Types.Error | SCIMMY.Messages.ErrorResponse.CauseDetails | Error); } export namespace ErrorResponse { /** * HTTP response status codes specified by RFC7644§3.12 */ export type ValidStatusCodes = 307 | 308 | 400 | 401 | 403 | 404 | 409 | 412 | 413 | 500 | 501; /** * SCIM detail error keywords specified by RFC7644§3.12 */ export type ValidScimTypes = "uniqueness" | "tooMany" | "invalidFilter" | "mutability" | "invalidSyntax" | "invalidPath" | "noTarget" | "invalidValue" | "invalidVers" | "sensitive"; /** * Details of the underlying cause of the error response */ export type CauseDetails = { /** * HTTP status code to be sent with the error */ status?: SCIMMY.Messages.ErrorResponse.ValidStatusCodes; /** * The SCIM detail error keyword as per [RFC7644§3.12]{@link https://datatracker.ietf.org/doc/html/rfc7644.section-3.12} */ scimType?: SCIMMY.Messages.ErrorResponse.ValidScimTypes; /** * A human-readable description of what caused the error to occur */ detail?: string; }; } export class ListResponse { /** * SCIM List Response Message Schema ID */ static readonly id: "urn:ietf:params:scim:api:messages:2.0:ListResponse"; /** * List exclusively containing the SCIM ListResponse message schema ID */ schemas: [typeof SCIMMY.Messages.ListResponse.id]; /** * Resources included in the list response */ Resources: T[]; /** * The total number of resources matching a given request */ totalResults: number; /** * Index within total results that included resources start from */ startIndex: number; /** * Maximum number of items returned in this list response */ itemsPerPage: number; /** * Instantiate a new SCIM List Response Message with relevant details * @param request Contents of the ListResponse message, or items to include in the list response * @param params Parameters for the list response (i.e. sort details, start index, and items per page) * @param params.sortBy The attribute to sort results by, if any * @param params.sortOrder The direction to sort results in, if sortBy is specified * @param params.startIndex Offset index that items start from * @param params.count Alias property for itemsPerPage, used only if itemsPerPage is unset * @param params.itemsPerPage Maximum number of items returned in this list response * @param params.totalResults The total number of resources matching a given request */ constructor(request: SCIMMY.Messages.ListResponse | T[], params?: SCIMMY.Messages.ListResponse.ListConstraints & { sortBy?: string; sortOrder?: string; startIndex?: number; count?: number; itemsPerPage?: number; totalResults?: number; }); } export namespace ListResponse { /** * ListResponse sort and pagination constraints */ export type ListConstraints = { /** * The attribute to sort results by, if any */ sortBy?: string; /** * The direction to sort results in, if sortBy is specified */ sortOrder?: string; /** * Offset index that items start from */ startIndex?: number; /** * Maximum number of items returned in this list response */ count?: number; }; } export class PatchOp { /** * SCIM Patch Operation Message Schema ID */ static readonly id: "urn:ietf:params:scim:api:messages:2.0:PatchOp"; /** * List exclusively containing the SCIM PatchOp message schema ID */ schemas: [typeof SCIMMY.Messages.PatchOp.id]; /** * List of SCIM-compliant patch operations to apply to the given resource */ Operations: SCIMMY.Messages.PatchOp.PatchOpOperation[]; /** * Instantiate a new SCIM Patch Operation Message with relevant details * @param request Contents of the patch operation request being performed * @param request.schemas List exclusively containing SCIM PatchOp message schema ID * @param request.Operations List of SCIM-compliant patch operations to apply to the given resource */ constructor(request?: { schemas: [typeof SCIMMY.Messages.PatchOp.id]; Operations: SCIMMY.Messages.PatchOp.PatchOpOperation[]; }); /** * Apply patch operations to a resource as defined by the PatchOp instance * @param resource The schema instance the patch operation will be performed on * @param finalise Method to call when all operations are complete, to feed target back through model * @returns An instance of the resource modified as per the included patch operations */ apply(resource: S, finalise?: SCIMMY.Messages.PatchOp.PatchOpFinaliser): Promise; } export namespace PatchOp { /** * List of valid SCIM patch operations */ export type ValidPatchOperations = "add" | "remove" | "replace"; /** * SCIM PatchOp Operation definition */ export type PatchOpOperation = { /** * The operation to perform */ op: SCIMMY.Messages.PatchOp.ValidPatchOperations; /** * An attribute path describing the target of the operation */ path?: string; /** * Value to add or update */ value?: any; }; /** * Apply final transformations or database operations before determining whether a PatchOp resulted in any actual changes * @param instance A patched version of the originally supplied resource schema instance * @returns The resource instance after final transformations have been applied */ export type PatchOpFinaliser = (instance: S) => Promise>; } export class BulkResponse { /** * SCIM BulkResponse Message Schema ID */ static readonly id: "urn:ietf:params:scim:api:messages:2.0:BulkResponse"; /** * List exclusively containing the SCIM BulkResponse message schema ID */ schemas: [typeof SCIMMY.Messages.BulkResponse.id]; /** * List of BulkResponse operation results */ Operations: SCIMMY.Messages.BulkResponse.BulkOpResponse[]; /** * Instantiate a new outbound SCIM BulkResponse message from the results of performed operations * @param operations Results of performed operations */ constructor(operations: SCIMMY.Messages.BulkResponse.BulkOpResponse[]); /** * Instantiate a new inbound SCIM BulkResponse message instance from the received response * @param request Contents of the received BulkResponse message * @param request.Operations List of SCIM-compliant bulk operation results */ constructor(request: { Operations: SCIMMY.Messages.BulkResponse.BulkOpResponse[]; }); /** * Instantiate a new SCIM BulkResponse message from the supplied Operations * @param request Results of performed operations if array * @param request Contents of the received BulkResponse message if object * @param request.Operations List of SCIM-compliant bulk operation results */ constructor(request: SCIMMY.Messages.BulkResponse.BulkOpResponse[] | { Operations: SCIMMY.Messages.BulkResponse.BulkOpResponse[]; }); /** * Resolve bulkIds of POST operations into new resource IDs * @returns Map of bulkIds to resource IDs if operation was successful, or false if not */ resolve(): Map; } export namespace BulkResponse { /** * BulkResponse operation response status codes */ export type ResponseStatusCodes = 200 | 201 | 204 | 307 | 308 | 400 | 401 | 403 | 404 | 409 | 412 | 500 | 501; /** * BulkResponse operation details for a given BulkRequest operation */ export type BulkOpResponse = { /** * Canonical URI for the target resource of the operation */ location?: string; /** * The HTTP method used for the requested operation */ method: SCIMMY.Messages.BulkRequest.ValidBulkMethods; /** * The transient identifier of a newly created resource, unique within a bulk request and created by the client */ bulkId?: string; /** * Resource version after operation has been applied */ version?: string; /** * The HTTP response status code for the requested operation */ status: SCIMMY.Messages.BulkResponse.ResponseStatusCodes; /** * The HTTP response body for the specified request operation */ response?: any; }; } export class BulkRequest { /** * SCIM BulkRequest Message Schema ID */ static readonly id: "urn:ietf:params:scim:api:messages:2.0:BulkRequest"; /** * List exclusively containing the SCIM BulkRequest message schema ID */ schemas: [typeof SCIMMY.Messages.BulkRequest.id]; /** * List of operations in this BulkRequest instance */ Operations: SCIMMY.Messages.BulkRequest.BulkOpOperation[]; /** * Number of error results a service provider should tolerate before aborting any following operations */ failOnErrors?: number; /** * Instantiate a new SCIM BulkRequest message from the supplied operations * @param request Contents of the BulkRequest operation being performed * @param request.schemas List exclusively containing the SCIM BulkRequest message schema ID * @param request.Operations List of SCIM-compliant bulk operations to apply * @param request.failOnErrors Number of error results to encounter before aborting any following operations * @param maxOperations Maximum number of operations supported in the request, as specified by the service provider */ constructor(request: { schemas: [typeof SCIMMY.Messages.BulkRequest.id]; Operations: SCIMMY.Messages.BulkRequest.BulkOpOperation[]; failOnErrors?: number; }, maxOperations?: number); /** * Apply the operations specified by the supplied BulkRequest and return a new BulkResponse message * @param resourceTypes Resource type classes to be used while processing bulk operations, defaults to declared resources * @param ctx Any additional context information to pass to the ingress, egress, and degress handlers * @returns A new BulkResponse Message instance with results of the requested operations */ apply(resourceTypes?: (typeof SCIMMY.Types.Resource)[], ctx?: any): Promise; } export namespace BulkRequest { /** * List of valid HTTP methods in a SCIM bulk request operation */ export type ValidBulkMethods = "POST" | "PUT" | "PATCH" | "DELETE"; /** * BulkRequest operation details */ export type BulkOpOperation = { /** * The HTTP method used for the requested operation */ method: SCIMMY.Messages.BulkRequest.ValidBulkMethods; /** * The transient identifier of a newly created resource, unique within a bulk request and created by the client */ bulkId?: string; /** * Resource version after operation has been applied */ version?: string; /** * The resource's relative path to the SCIM service provider's root */ path?: string; /** * The resource data as it would appear for the corresponding single SCIM HTTP request */ data?: any; }; } export class SearchRequest { /** * SCIM SearchRequest Message Schema ID */ static readonly id: "urn:ietf:params:scim:api:messages:2.0:SearchRequest"; /** * List exclusively containing the SCIM SearchRequest message schema ID */ schemas: [typeof SCIMMY.Messages.SearchRequest.id]; /** * The filter to be applied on ingress/egress by implementing resource */ filter?: string; /** * The string list of attributes or filters to exclude on egress */ excludedAttributes?: string[]; /** * The string list of attributes or filters to include on egress */ attributes?: string[]; /** * The attribute retrieved resources should be sorted by */ sortBy?: string; /** * The direction retrieved resources should be sorted in */ sortOrder?: string; /** * Offset index that retrieved resources should start from */ startIndex?: number; /** * Maximum number of retrieved resources that should be returned in one operation */ count?: number; /** * Instantiate a new SCIM SearchRequest message from the supplied request * @param request Contents of the SearchRequest received by the service provider * @param request.schemas List exclusively containing the SCIM SearchRequest message schema ID * @param request.filter The filter to be applied on ingress/egress by implementing resource * @param request.excludedAttributes The string list of attributes or filters to exclude on egress * @param request.attributes The string list of attributes or filters to include on egress * @param request.sortBy The attribute retrieved resources should be sorted by * @param request.sortOrder The direction retrieved resources should be sorted in * @param request.startIndex Offset index that retrieved resources should start from * @param request.count Maximum number of retrieved resources that should be returned in one operation */ constructor(request?: { schemas: [typeof SCIMMY.Messages.SearchRequest.id]; filter?: string; excludedAttributes?: string[]; attributes?: string[]; sortBy?: string; sortOrder?: string; startIndex?: number; count?: number; }); /** * Prepare a new search request for transmission to a service provider * @param params Details of the search request to be sent to a service provider * @param params.filter The filter to be applied on ingress/egress by implementing resource * @param params.excludedAttributes The string list of attributes or filters to exclude on egress * @param params.attributes The string list of attributes or filters to include on egress * @param params.sortBy The attribute retrieved resources should be sorted by * @param params.sortOrder The direction retrieved resources should be sorted in * @param params.startIndex Offset index that retrieved resources should start from * @param params.count Maximum number of retrieved resources that should be returned in one operation * @returns This SearchRequest instance for chaining */ prepare(params?: { filter?: string; excludedAttributes?: string[]; attributes?: string[]; sortBy?: string; sortOrder?: string; startIndex?: number; count?: number; }): SCIMMY.Messages.SearchRequest; /** * Apply a search request operation, retrieving results from specified resource types * @param resourceTypes Resource type classes to be used while processing the search request, defaults to declared resources * @param ctx Any additional context information to pass to the egress handler * @returns A ListResponse message with results of the search request */ apply(resourceTypes?: (typeof SCIMMY.Types.Resource)[], ctx?: any): Promise; } } export class Schemas { /** * Register a SchemaDefinition implementation for exposure via Schemas HTTP endpoint * @param definition The schema definition to register * @param name The name of the definition being declared, if different from definition's name property * @returns The Schemas class for chaining */ static declare(definition: SCIMMY.Types.SchemaDefinition, name?: string): SCIMMY.Schemas; /** * Get all declared schema definitions * @returns Array containing all declared schema definitions */ static declared(): SCIMMY.Types.SchemaDefinition[]; /** * Get the declared schema definition for the given name or ID * @param definition Declared name or ID of schema definition to retrieve * @returns The declared schema definition with matching name or ID */ static declared(definition: string): SCIMMY.Types.SchemaDefinition; /** * Query the declaration status of a given schema definition instance * @param definition The schema definition instance to query declaration status for * @returns The declaration status of the specified schema definition */ static declared(definition: SCIMMY.Types.SchemaDefinition): boolean; /** * Get declaration status of specific schema definition, or get all declared schema definitions * @param definition The schema definition or name to query declaration status for * @returns Array containing declared schema definitions for exposure via Schemas HTTP endpoint, if no arguments are supplied. * @returns The declared schema definition with matching name or ID, or undefined, if a string argument is supplied. * @returns The declaration status of the specified schema definition, if a class extending `SCIMMY.Types.SchemaDefinition` was supplied. */ static declared(definition?: SCIMMY.Types.SchemaDefinition | string): SCIMMY.Types.SchemaDefinition[] | SCIMMY.Types.SchemaDefinition | boolean; } export namespace Schemas { export class User extends Types.Schema { static readonly id: "urn:ietf:params:scim:schemas:core:2.0:User"; /** * Unique identifier for the User, typically used by the user to directly authenticate to the service provider. Each User MUST include a non-empty userName value. This identifier MUST be unique across the service provider's entire set of Users. REQUIRED */ userName: string; /** * The components of the user's real name. Providers MAY return just the full name as a single string in the formatted sub-attribute, or they MAY return just the individual component attributes using the other sub-attributes, or they MAY return both. If both variants are returned, they SHOULD be describing the same name, with the formatted name indicating how the component attributes should be combined */ name?: { /** * The full name, including all middle names, titles, and suffixes as appropriate, formatted for display (e.g. 'Ms. Barbara J Jensen, III') */ formatted?: string; /** * The family name of the User, or last name in most Western languages (e.g. 'Jensen' given the full name 'Ms. Barbara J Jensen, III') */ familyName?: string; /** * The given name of the User, or first name in most Western languages (e.g. 'Barbara' given the full name 'Ms. Barbara J Jensen, III') */ givenName?: string; /** * The middle name(s) of the User (e.g. 'Jane' given the full name 'Ms. Barbara J Jensen, III') */ middleName?: string; /** * The honorific prefix(es) of the User, or title in most Western languages (e.g. 'Ms.' given the full name 'Ms. Barbara J Jensen, III') */ honorificPrefix?: string; /** * The honorific suffix(es) of the User, or suffix in most Western languages (e.g. 'III' given the full name 'Ms. Barbara J Jensen, III') */ honorificSuffix?: string; }; /** * The name of the User, suitable for display to end-users. The name SHOULD be the full name of the User being described, if known */ displayName?: string; /** * The casual way to address the user in real life, e.g. 'Bob' or 'Bobby' instead of 'Robert'. This attribute SHOULD NOT be used to represent a User's username (e.g. 'bjensen' or 'mpepperidge') */ nickName?: string; /** * A fully qualified URL pointing to a page representing the User's online profile */ profileUrl?: string; /** * The user's title, such as 'Vice President' */ title?: string; /** * Used to identify the relationship between the organization and the user. Typical values used might be 'Contractor', 'Employee', 'Intern', 'Temp', 'External', and 'Unknown', but any value may be used */ userType?: string; /** * Indicates the User's preferred written or spoken language. Generally used for selecting a localized user interface; e.g. 'en_US' specifies the language English and country US */ preferredLanguage?: string; /** * Used to indicate the User's default location for purposes of localizing items such as currency, date time format, or numerical representations */ locale?: string; /** * The User's time zone in the 'Olson' time zone database format, e.g. 'America/Los_Angeles' */ timezone?: string; /** * A Boolean value indicating the User's administrative status */ active?: boolean; /** * The User's cleartext password. This attribute is intended to be used as a means to specify an initial password when creating a new User or to reset an existing User's password */ password?: string; /** * Email addresses for the user. The value SHOULD be canonicalized by the service provider, e.g. 'bjensen@example.com' instead of 'bjensen@EXAMPLE.COM'. Canonical type values of 'work', 'home', and 'other' */ emails?: Array<{ /** * Email addresses for the user. The value SHOULD be canonicalized by the service provider, e.g. 'bjensen@example.com' instead of 'bjensen@EXAMPLE.COM'. Canonical type values of 'work', 'home', and 'other' */ value: string; /** * A human-readable name, primarily used for display purposes */ display?: string; /** * A label indicating the attribute's function, e.g. 'work' or 'home' */ type?: string; /** * A Boolean value indicating the 'primary' or preferred attribute value for this attribute, e.g. the preferred mailing address or primary email address. The primary attribute value 'true' MUST appear no more than once */ primary?: boolean; }>; /** * Phone numbers for the User. The value SHOULD be canonicalized by the service provider according to the format specified in RFC 3966, e.g. 'tel:+1-201-555-0123'. Canonical type values of 'work', 'home', 'mobile', 'fax', 'pager', and 'other' */ phoneNumbers?: Array<{ /** * Phone number of the User */ value: string; /** * A human-readable name, primarily used for display purposes */ display?: string; /** * A label indicating the attribute's function, e.g. 'work', 'home', 'mobile' */ type?: string; /** * A Boolean value indicating the 'primary' or preferred attribute value for this attribute, e.g. the preferred phone number or primary phone number. The primary attribute value 'true' MUST appear no more than once */ primary?: boolean; }>; /** * Instant messaging addresses for the User */ ims?: Array<{ /** * Instant messaging address for the User */ value: string; /** * A human-readable name, primarily used for display purposes */ display?: string; /** * A label indicating the attribute's function, e.g. 'aim', 'gtalk', 'xmpp' */ type?: string; /** * A Boolean value indicating the 'primary' or preferred attribute value for this attribute, e.g. the preferred messenger or primary messenger. The primary attribute value 'true' MUST appear no more than once */ primary?: boolean; }>; /** * URLs of photos of the User */ photos?: Array<{ /** * URL of a photo of the User */ value: string; /** * A human-readable name, primarily used for display purposes */ display?: string; /** * A label indicating the attribute's function, i.e., 'photo' or 'thumbnail' */ type?: string; /** * A Boolean value indicating the 'primary' or preferred attribute value for this attribute, e.g. the preferred photo or thumbnail. The primary attribute value 'true' MUST appear no more than once */ primary?: boolean; }>; /** * A physical mailing address for this User. Canonical type values of 'work', 'home', and 'other' */ addresses?: Array<{ /** * The full mailing address, formatted for display or use with a mailing label. This attribute MAY contain newlines */ formatted?: string; /** * The full street address component, which may include house number, street name, P.O. box, and multi-line extended street address information */ streetAddress?: string; /** * The city or locality component */ locality?: string; /** * The state or region component */ region?: string; /** * The zip code or postal code component */ postalCode?: string; /** * The country name component */ country?: string; /** * A label indicating the attribute's function, e.g. 'work' or 'home' */ type?: string; /** * A Boolean value indicating the 'primary' or preferred attribute value for this attribute, e.g. the preferred mailing address or primary email address */ primary?: boolean; }>; /** * A list of groups to which the user belongs, either through direct membership, through nested groups, or dynamically calculated */ groups?: Array<{ /** * The identifier of the User's group */ value: string; /** * The URI of the corresponding 'Group' resource to which the user belongs */ $ref?: string; /** * A human-readable name, primarily used for display purposes */ display?: string; /** * A label indicating the attribute's function, e.g. 'direct' or 'indirect' */ type?: string; }>; /** * A list of entitlements for the User that represent a thing the User has */ entitlements?: Array<{ /** * The value of an entitlement */ value: string; /** * A human-readable name, primarily used for display purposes */ display?: string; /** * A label indicating the attribute's function */ type?: string; /** * A Boolean value indicating the 'primary' or preferred attribute value for this attribute. The primary attribute value 'true' MUST appear no more than once */ primary?: boolean; }>; /** * A list of roles for the User that collectively represent who the User is, e.g. 'Student', 'Faculty' */ roles?: Array<{ /** * The value of a role */ value: string; /** * A human-readable name, primarily used for display purposes */ display?: string; /** * A label indicating the attribute's function */ type?: string; /** * A Boolean value indicating the 'primary' or preferred attribute value for this attribute. The primary attribute value 'true' MUST appear no more than once */ primary?: boolean; }>; /** * A list of certificates issued to the User */ x509Certificates?: Array<{ /** * The value of an X.509 certificate */ value: string; /** * A human-readable name, primarily used for display purposes */ display?: string; /** * A label indicating the attribute's function */ type?: string; /** * A Boolean value indicating the 'primary' or preferred attribute value for this attribute. The primary attribute value 'true' MUST appear no more than once */ primary?: boolean; }>; /** * Instantiates a new user that conforms to the SCIM User schema definition * @param resource The source data to feed through the schema definition * @param direction Whether the resource is inbound from a request or outbound for a response * @param basepath The base path for resolution of a resource's location * @param filters Attribute filters to apply to the coerced value */ constructor(resource: any, direction?: string, basepath?: string, filters?: SCIMMY.Types.Filter); } export class Group extends Types.Schema { static readonly id: "urn:ietf:params:scim:schemas:core:2.0:Group"; /** * A human-readable name for the Group */ displayName: string; /** * A list of members of the Group */ members?: Array<{ /** * Identifier of the member of this Group */ value: string; /** * Human-readable name of the member of this Group */ display?: string; /** * The URI corresponding to a SCIM resource that is a member of this Group */ $ref?: string; /** * A label indicating the type of resource, e.g., 'User' or 'Group' */ type?: string; }>; /** * Instantiates a new group that conforms to the SCIM Group schema definition * @param resource The source data to feed through the schema definition * @param direction Whether the resource is inbound from a request or outbound for a response * @param basepath The base path for resolution of a resource's location * @param filters Attribute filters to apply to the coerced value */ constructor(resource: any, direction?: string, basepath?: string, filters?: SCIMMY.Types.Filter); } export class EnterpriseUser extends Types.Schema { static readonly id: "urn:ietf:params:scim:schemas:extension:enterprise:2.0:User"; /** * Numeric or alphanumeric identifier assigned to a person, typically based on order of hire or association with an organization */ employeeNumber?: string; /** * Identifies the name of a cost center */ costCenter?: string; /** * Identifies the name of an organization */ organization?: string; /** * Identifies the name of a division */ division?: string; /** * Identifies the name of a department */ department?: string; /** * The User's manager */ manager?: { /** * The id of the SCIM resource representing the User's manager */ value: string; /** * The URI of the SCIM resource representing the User's manager */ $ref?: string; /** * The displayName of the User's manager */ displayName?: string; }; /** * Instantiates a new enterprise user that conforms to the SCIM EnterpriseUser schema definition * @param resource The source data to feed through the schema definition * @param direction Whether the resource is inbound from a request or outbound for a response * @param basepath The base path for resolution of a resource's location * @param filters Attribute filters to apply to the coerced value */ constructor(resource: any, direction?: string, basepath?: string, filters?: SCIMMY.Types.Filter); } export class ResourceType extends Types.Schema { static readonly id: "urn:ietf:params:scim:schemas:core:2.0:ResourceType"; /** * The resource type name. When applicable, service providers MUST specify the name, e.g., 'User' */ name: string; /** * The resource type's human-readable description. When applicable, service providers MUST specify the description */ description?: string; /** * The resource type's HTTP-addressable endpoint relative to the Base URL, e.g., '/Users' */ endpoint: string; /** * The resource type's primary/base schema URI */ schema: string; /** * A list of URIs of the resource type's schema extensions */ schemaExtensions?: Array<{ /** * The URI of a schema extension */ schema: string; /** * A Boolean value that specifies whether the schema extension is required for the resource type */ required: boolean; }>; /** * Instantiates a new resource type that conforms to the SCIM ResourceType schema definition * @param resource The source data to feed through the schema definition * @param basepath The base path for resolution of a resource's location */ constructor(resource: any, basepath?: string); } export class ServiceProviderConfig extends Types.Schema { static readonly id: "urn:ietf:params:scim:schemas:core:2.0:ServiceProviderConfig"; id: never; /** * An HTTP-addressable URL pointing to the service provider's human-consumable help documentation */ documentationUri: string; /** * A complex type that specifies PATCH configuration options */ patch: { /** * A Boolean value specifying whether the operation is supported */ supported: boolean; }; /** * A complex type that specifies bulk configuration options */ bulk: { /** * A Boolean value specifying whether the operation is supported */ supported: boolean; /** * An integer value specifying the maximum number of operations */ maxOperations: number; /** * An integer value specifying the maximum payload size in bytes */ maxPayloadSize: number; }; /** * A complex type that specifies FILTER options */ filter: { /** * A Boolean value specifying whether the operation is supported */ supported: boolean; /** * An integer value specifying the maximum number of resources returned in a response */ maxResults: number; }; /** * A complex type that specifies configuration options related to changing a password */ changePassword: { /** * A Boolean value specifying whether the operation is supported */ supported: boolean; }; /** * A complex type that specifies sort result options */ sort: { /** * A Boolean value specifying whether the operation is supported */ supported: boolean; }; /** * A complex type that specifies ETag configuration options */ etag: { /** * A Boolean value specifying whether the operation is supported */ supported: boolean; }; /** * A complex type that specifies supported authentication scheme properties */ authenticationSchemes: Array<{ /** * The authentication scheme */ type: string; /** * The common authentication scheme name, e.g., HTTP Basic */ name: string; /** * A description of the authentication scheme */ description: string; /** * An HTTP-addressable URL pointing to the authentication scheme's specification */ specUri?: string; /** * An HTTP-addressable URL pointing to the authentication scheme's usage documentation */ documentationUri?: string; }>; /** * Instantiates a new service provider configuration that conforms to the SCIM ServiceProviderConfig schema definition * @param resource The source data to feed through the schema definition * @param basepath The base path for resolution of a resource's location */ constructor(resource: any, basepath?: string); } } export class Resources { /** * Register a resource implementation and return it for chained configuration * @param resource The resource type implementation to register * @param config The explicit name to register the resource implementation with * @returns The registered resource type class for chaining */ static declare>(resource: R, config?: string): R; /** * Register a resource implementation with specific config, returning Resources class for chained registrations * @param resource The resource type implementation to register * @param config The configuration to feed to the resource being registered * @returns The Resources class for chaining */ static declare>(resource: R, config: any): typeof SCIMMY.Resources; /** * Register a resource implementation for exposure as a ResourceType * @param resource The resource type implementation to register * @param config The configuration to feed to the resource being registered, or the name of the resource type implementation if different to the class name * @returns The Resources class or registered resource type class for chaining */ static declare(resource: typeof SCIMMY.Types.Resource, config?: any | string): typeof SCIMMY.Resources | typeof SCIMMY.Types.Resource; /** * Get all registered resource implementations * @returns A containing object with all registered resource implementations */ static declared(): Record; /** * Get the registered resource type implementation for the given name * @param resource Registered name of resource to retrieve * @returns The registered resource type implementation with matching name */ static declared(resource: string): typeof SCIMMY.Types.Resource; /** * Query the registration status of a given resource type implementation * @param resource The resource type implementation to query registration status for * @returns The registration status of the specified resource type implementation class */ static declared>(resource: R): boolean; /** * Get registration status of specific resource implementation, or get all registered resource implementations * @param resource The resource implementation or name to query registration status for * @returns A containing object with registered resource implementations for exposure as ResourceTypes, if no arguments are supplied. * @returns The registered resource type implementation with matching name, or undefined, if a string argument is supplied. * @returns The registration status of the specified resource implementation, if a class extending `SCIMMY.Types.Resource` is supplied. */ static declared(resource?: typeof SCIMMY.Types.Resource | string): Record | typeof SCIMMY.Types.Resource | boolean; } export namespace Resources { export class User extends SCIMMY.Types.Resource { static readonly endpoint: "/Users"; static basepath: SCIMMY.Types.Resource.basepath; static readonly schema: typeof SCIMMY.Schemas.User; static extend: SCIMMY.Types.Resource.extend; static ingress: SCIMMY.Types.Resource.ingress; static egress: SCIMMY.Types.Resource.egress; static degress: SCIMMY.Types.Resource.degress; } export class Group extends SCIMMY.Types.Resource { static readonly endpoint: "/Groups"; static basepath: SCIMMY.Types.Resource.basepath; static readonly schema: typeof SCIMMY.Schemas.Group; static extend: SCIMMY.Types.Resource.extend; static ingress: SCIMMY.Types.Resource.ingress; static egress: SCIMMY.Types.Resource.egress; static degress: SCIMMY.Types.Resource.degress; } export class Schema extends SCIMMY.Types.Resource { static readonly endpoint: "/Schemas"; static basepath: SCIMMY.Types.Resource.basepath; static extend(): never; } export class ResourceType extends SCIMMY.Types.Resource { static readonly endpoint: "/ResourceTypes"; static basepath: SCIMMY.Types.Resource.basepath; static extend(): never; } export class ServiceProviderConfig extends SCIMMY.Types.Resource { static readonly endpoint: "/ServiceProviderConfig"; static basepath: SCIMMY.Types.Resource.basepath; static extend(): never; } } export class Config { /** * Get SCIM service provider configuration * @returns The service provider configuration, proxied for protection */ static get(): any; /** * Set multiple SCIM service provider configuration property values * @param config The new configuration to apply to the service provider config instance * @returns The updated configuration instance */ static set(config: any): any; /** * Set specific SCIM service provider configuration property by name * @param name The name of the configuration property to set * @param value The new value of the configuration property to set * @returns The config container class for chaining */ static set(name: string, value: any | boolean): typeof SCIMMY.Config; /** * Set SCIM service provider configuration * @param name The configuration key name or value to apply * @param config The new configuration to apply to the service provider config instance * @returns The updated configuration instance, or the config container class for chaining */ static set(name: any | string, config?: any | string | boolean): any | typeof SCIMMY.Config; } } }