GridFieldDropdownFilter provides a dropdown that can be used to filter a GridField arbitrarily

Facilitates adding arbitrary HTML to grid fields

A button that contains a link to an URL.

Adds a "Refresh" button to the bottom or top of a GridField.

Refresh report job. Runs as a queued job.

Describes an installed composer package version.

A report listing all installed modules used in this site (from a cache).

Parses a composer lock file in order to cache information about the installation.

Handles fetching supported module details

The composer loader class is responsible for dealing directly with composer.json and composer.lock files, in terms of loading and parsing their contents.

Handles fetching module health information from

Handles fetching supported addon details from

Task which does the actual checking of updates

Describes any available updates to an installed Composer package

The update checker class is provided a {@link Link} object representing a package and uses the Composer API to determine the next available updates for the package.

Class CWPPageExtension

Class CWPCleanupSiteConfigExtension

Bulk action handler for recursive archiving records.

Bulk action handler for deleting records.

Bulk action handler for editing records.

Base class to extend for all custom bulk action handlers Gives access to the GridField, Component and Controller and implements useful functions like {@link getRecordIDList()} and {@link getRecords()}.

Bulk action handler for recursive publishing records.

Bulk action handler for recursive unpublishing records.

Bulk action handler for unlinking records.

GridField component for editing attached models in bulk.

Custom HTTPResponse for all bulk tools to use for a unified response format and facilitate forn-end handling

Custom UploadField used to override Link() and redirect UploadField action properly through the GridField.

Handles request from the GridFieldBulkUpload component.

GridField component for uploading images in bulk.

Optional controller for every element which has its own logic, e.g. in forms.

Controller for "ElementalArea" - handles loading and saving of in-line edit forms in an elemental area in admin

This extension handles most of the relationships between pages and element area, it doesn't add an ElementArea to the page however. Because of this, developers can add multiple {@link ElementArea} areas to to a page.

Class GridFieldAddNewMultiClassHandlerExtension

Class BaseElement

Class ElementalArea

Class DataExtension

Class FluentExtension

Class SiteTreeExtension

A class representing back actions.

Special request handler for admin/batchaction

An extension that automatically generates a CMS edit link for DataObjects even if they are canonically edited in some nested {@link GridField}.

The object manages the main CMS menu. See {@link LeftAndMain::init()} for example usage.

A simple CMS menu item.

Abstract form builder for insert link form

Provides a table which displays the provided record's owners

LeftAndMain is the parent class of all the two-pane views in the CMS.

Plug-ins for additional functionality in your LeftAndMain classes.

Allows CMS forms to be decorated with additional context arguments.

Allow overriding finished state for faux redirects.

Abstract interface for a class which may be used to filter the results displayed in a nested tree

Parent controller for all CMS-global modals

Generates a three-pane UI for editing model classes, tabular results and edit forms.

Utility class representing links to different views of a record for CMS authors, usually for {@link SiteTree} objects with "stage" and "live" links.

SilverStripeNavigator items are links that appear in the $SilverStripeNavigator bar.

Security section of the CMS

Responsible for checking and verifying whether sudo mode is enabled

Delete multiple {@link Folder} records (and the associated filesystem nodes).

AssetAdmin is the 'file store' section of the CMS.

Update File dataobjects to be editable in this asset admin

This exception is thrown by RemoteFileFormFactory when failing to fetch an embeddable remote resource because it's either an invalid URL or because the resource is invalid

Extension that updates the Popover menu of FileFormFactory.

Decorates ModalController with an insert-oembed modal

Hides several types of DataObjects on the "Used On" tab when viewing files

Scaffolds a form for searching files

Empty form factory, because the defaults from AssetFormFactory was enough

History view for file editor form

For providing schema data to the client side to build a preview field with upload replacement feature

Represents a file upload field with ReactJS based frontend.

Represents a notice related to a graphql Action. This could be a failure, warning, or recoverable query (e.g. "are you sure you want to publish this item?")

Generate thumbnails and thumbnail links

This class provides the necessary business logic to ensure that any assets attached to a record are safely deleted, published, or protected during certain operations.

Provides a mechanism for determining the effective visibility of a set of assets (identified by filename and hash), given their membership to objects of varying visibility.

A task to manually flush InterventionBackend cache

Allows you to mock a backend store in a custom directory beneath assets.

This class handles the representation of a file on the filesystem within the framework.

Permissions for root files with Can*Type = Inherit

A utility class that finds any files matching a set of rules that are present within a directory tree.

Filter certain characters from file name, for nicer (more SEO-friendly) URLs as well as better filesystem compatibility.

Helps build and parse Filename Identifiers (ake: FileIDs) according to a predefined format.

File resolution strategy that relies on a list of FileIDHelpers to find files.

Represents a strategy for resolving files on a Flysystem Adapter.

Parsed Hash path URLs. Hash paths group a file and its variant under a directory based on a hash generated from the content of the original file.

Parsed Natural path URLs. Natural path is the same hashless path that appears in the CMS.

Immutable representation of a parsed fileID broken down into its sub-components.

A collection of static methods for manipulating the filesystem.

Adapter for local filesystem based on assets directory

Asset store based on flysystem Filesystem as a backend

Simple Flysystem implementation of GeneratedAssetHandler for storing generated content

An adapter which does not publicly expose protected files

Represents an AbstractAdapter which exposes its assets via public urls

Represents a logical folder, which may be used to organise assets stored in the configured backend.

Filter certain characters from file name, for nicer (more SEO-friendly) URLs as well as better filesystem compatibility.

Represents an Image

Creates backends for images as necessary, avoiding redundant asset writes and loads

Provides image manipulation functionality.


Represents a link between a dataobject parent and a file shortcode in a HTML content area

Adds tracking of links in any HTMLText fields which reference SiteTree or File items.

A helper object for extracting information about links.

Provides shortcodes for File dataobject

Class ImageShortcodeProvider

Represents a container for a specific asset.

Provides a mechanism for suggesting filename alterations to a file

Represents an abstract asset persistence layer. Acts as a backend to files.

Represents a store usable with ProtectedFileController to serve up non-direct file requests

Represents a file reference stored in a database

Basic filename renamer

Utility for computing and comparing unique file hash. All $fs parameters can either be:

  • an AssetStore constant VISIBILITY constant or
  • an actual Filesystem object.

Interface to define a handler for persistent generated files

Provides routing for session-whitelisted protected files

Utility for computing and comparing unique file hash. All $fs parameters can either be:

  • an AssetStore constant VISIBILITY constant or
  • an actual Filesystem object.

An object which may have a thumbnail url

Manages uploads via HTML forms processed by PHP, uploads to Silverstripe's default upload directory, and either creates a new or uses an existing File-object for syncing with the database.

Logs are written using a side-channel, because audit trail should not be mixed up with regular PHP errors.

Provides logging hooks that are inserted into Framework objects.

Provides logging actions on extension hooks from certain silverstripe/mfa actions.

Provides logging actions on extension hooks from certain silverstripe/session-manager actions.

Provides a component to the {@link GridField} which tells the user whether or not a blog post has been published and when.

GridField config necessary for managing a SiteTree object.

Blog Holder

A blog category for generalising blog posts.

Adds Blog specific behaviour to Comment.

This class is responsible for filtering the SiteTree when necessary and also overlaps into filtering only published posts.

Enables children of non-editable pages to be edited.

This class is responsible for add Blog specific behaviour to Members.

An object shared by BlogTag and BlogCategory.

An individual blog post.

Adds a checkbox field for featured blog posts widget.

This is responsible for filtering only published posts to users who do not have permission to view non-published posts.

Customise blog post to support comment notifications.

A blog tag for keyword descriptions of a blog post.

Delete items batch action.

Publish items batch action.

Batch restore of pages

Unpublish items batch action.

The main "content" area of the CMS.

Base class for filtering the subtree for certain node statuses.

Gets all pages which have changed on stage.

Works a bit different than the other filters: Shows all pages including those deleted from stage and live.

This filter will display the SiteTree as a site visitor might see the site, i.e only the pages that is currently published.

Filters pages which have a status "Deleted".

Filters pages which have a status "Draft".

Filters pages which have a status "Removed from Draft".

The most common kind of controller; effectively a controller linked to a {@link DataObject}.

Extension to include custom page icons

ModelAsController deals with mapping the initial request to the first {@link SiteTree}/{@link ContentController} pair, which are then used to handle the request.

Assists with selecting anchors on a given page

Provides a form factory for inserting internal page links in a HTML editor

Decorates ModalController with insert internal link

Used to edit the SiteTree->URLSegment property, and suggest input based on the serverside rules defined through {@link SiteTree->generateURLSegment()} and {@link URLSegmentFilter}.

Readonly version of a site tree URL segment field

This interface lets us set up objects that will tell us what the current page is.

A redirector page redirects when the page is visited.

Controller for the {@link RedirectorPage}.

Basic data-object representing all pages within the site tree. All page types that live within the hierarchy should inherit from this. In addition, it contains a number of static methods for querying the site tree and working with draft and published states.

Plug-ins for additional functionality in your SiteTree classes.

Represents a link between a dataobject parent and a page in a HTML content area

Adds tracking of links in any HTMLText fields which reference SiteTree or File items.

A helper object for extracting information about links.

Virtual Page creates an instance of a page, with the same fields that the original page had, but readonly.

Content side-report listing pages with broken links

Extension to provide a search interface when applied to ContentController

Standard basic search form which conducts a fulltext search on all {@link SiteTree} objects.

Class AddToCampaignHandler - handle the AddToCampaign action.

A form action to return from geCMSActions or otherwise include in a CMS Edit Form that has the right action name and CSS classes to trigger the AddToCampaignHandler.

Campaign section of the CMS

Warning: Volatile API as placeholder for standard "GridField"

Handles adding the "Add to Campaign" button to a page's secondary actions menu

This represents a collection of config keys and values.

Applies config modifications as a set of deltas on top of the middleware, instead of as modifications to the underlying list.

Basic mutable config collection stored in memory

Applies a set of user-customised modifications to config

Abstract flag-aware middleware

This is a helper class which lets us do things with content review data without subsites messing our SQL queries up.

CMSPageEditController extension to receive the additional action button from SiteTreeContentReview::updateCMSActions()

This extensions add a default schema for new pages and pages without a content review setting.

Set dates at which content needs to be reviewed and provide a report and emails to alert to content needing review.

Allows the content review module to use the optional queued jobs module to automatically process content review emails. If the module isn't installed, nothing is done - SilverStripe will never include this class declaration.

Show all pages that need to be reviewed.

Show all pages that need to be reviewed.

Daily task to send emails to the owners of content items when the review date rolls around.

Task which migrates the ContentReview Module's SiteTree->OwnerID column to a new column name.

CLI specific request building logic

Base class invoked from CLI rather than the webserver (Cron jobs, handling email bounces).

The content negotiator performs "text/html" or "application/xhtml+xml" switching. It does this through the public static function ContentNegotiator::process(). By default, ContentNegotiator will comply to the Accept headers the clients sends along with the HTTP request, which is most likely "application/xhtml+xml" (see "Order of selection" below).

Controllers are the cornerstone of all site functionality in SilverStripe. The {@link Director} selects a controller to pass control to, and then calls {@link handleRequest()}. This method will execute the appropriate action - either by calling the action method, or displaying the action's template.

A set of static methods for manipulating cookies.

A default backend for the setting and getting of cookies

The Cookie_Backend interface for use with Cookie::$inst.

Director is responsible for processing URLs, and providing environment information.

This subscriber is registered in BaseKernel->bootEmail()

A class with HTTP-related helpers. Like Debug, this is more a bundle of methods than a class.

Represents a HTTP-request, including a URL that is tokenised for parsing, and a request method (GET/POST/PUT/DELETE). This is used by {@link RequestHandler} objects to decide what to do.

Represents a response returned by a controller.

A {@link HTTPResponse} encapsulated in an exception, which can interrupt the processing flow and be caught by the {@link RequestHandler} and returned to the user.

A response which contains a streamable data source.

Indicator for a class which cannot handle requests directly, but is able to generate a delegate for those requests.

Secures requests by only allowing a whitelist of Host values

Implements the following URL normalisation rules

  • redirect basic auth requests to HTTPS
  • force WWW, redirect to the subdomain "www."
  • force SSL, redirect to https
  • force the correct path (with vs without trailing slash)

Handles internal change detection via etag / ifmodifiedsince headers, conditionally sending a 304 not modified if possible.

Checks whether user manual confirmation is required for HTTPRequest depending on the rules given.

Bypass for AJAX requests

A bypass for manual confirmation by user (depending on some runtime conditions)

Allows a bypass when the request has been run in CLI mode

Allows a bypass for a list of environment types (e.g. DEV, TEST, LIVE)

A rule to match a GET parameter within HTTPRequest

Allows to bypass requests of a particular HTTP method

Path aware trait for rules and bypasses

A rule for checking whether we need to protect a Request


A rule to match a particular URL

A rule to match beginning of URL

A case insensitive rule to match beginning of URL

Display execution metrics for the current request if in dev mode and execmetric is provided as a request variable.

Triggers a call to flush() on all implementors of Flushable.

Adds middleware support to an object.

Extends the ConfirmationMiddleware with checks for user permissions

Decorates a request handler with the HTTP Middleware pattern

This middleware will rewrite headers that provide IP and host details from an upstream proxy.

Check the request for the URL special variables.

Schedule flush operation for a following request

Implements switching user session into Test and Dev environment types

Interface that is implemented by controllers that are designed to hand control over to another controller.

Implements the "Null Object" pattern for a missing http request.

Handle the X-Pjax header that AJAX responses may provide, returning the fragment, or, in the case of non-AJAX form submissions, redirecting back to the submitter.

RSSFeed class

RSSFeed_Entry class

This class is the base class of any SilverStripe object that can be used to handle HTTP requests.

Handles all manipulation of the session.

Generate URLs assuming that BASE_PATH is also the webroot Standard SilverStripe 3 operation

Http utility functions.

Identifies a class as a root silverstripe application

Simple Kernel container

Returns the most performant combination of caches available on the system:

  • PhpFilesCache (PHP 7 with opcache enabled)
  • ApcuCache (requires APC) with a FilesystemCache fallback (for larger cache volumes)
  • FilesystemCache if none of the above is available

Assists with building of manifest cache prior to config being available

Defines a service that can flush its cache for a list of members

Provides introspection information about the class tree.

Registers config sources via ConfigCollectionInterface

Provides extensions to this object to integrate it with standard config API methods.

Factory for silverstripe configs

Library of conversion functions, implemented as static methods.

Simple Kernel container

Allows an object to declare a set of custom methods

Consolidates access and modification of PHP global variables and settings.

Loads environment variables from .env files Loosely based on

Allows an object to have extensions applied to it.

Add extension that can be added to an object with {@link Object::add_extension()}.

Provides an interface for classes to implement their own flushing functionality whenever flush=1 is requested.

An AfterCallAspect is run after a method is executed

A class that proxies another, allowing various functionality to be injected.

A BeforeCallAspect is run before a method is executed.

A factory which is used for creating service instances.

A class that can be instantiated or replaced via DI

A class for creating new objects by the injector.

A simple injection manager that manages creating objects and injecting dependencies between them. It borrows quite a lot from ideas taken from Spring's configuration, but is adapted to the stateless PHP way of doing things.

Registers chained injectors

Used to locate configuration for a particular named service.

Use the SilverStripe configuration system to lookup config for a particular service.

Represents the core state of a SilverStripe application Based loosely on symfony/http-kernel's KernelInterface component

Class ClassContentRemover

A class that handles loading classes and interfaces from a class manifest instance.

A utility class which builds a manifest of all classes, interfaces and caches it.

Error handler which throws, but retains the original path context.

An extension to the default file finder with some extra filters to facilitate autoload and template manifest generation:

  • Only modules with _config.php files are scanned.

Abstraction of a PHP Package. Can be used to retrieve information about Silverstripe CMS modules, and other packages managed via composer, by reading their composer.json file.

Module manifest holder

A utility class which builds a manifest of configuration items

This object represents a single resource file attached to a module, and can be used as a reference to this to be later turned into either a URL or file path.

Helper for mapping module resources to paths / urls

Sorts an associative array of items given a list of priorities, where priorities are the keys of the items in the order they are desired.

Generate URLs for client-side assets and perform any preparation of those assets needed.

The version provider will look up configured modules and examine the composer.lock file to find the current version installed for each. This is used for the logo title in the CMS via {@link LeftAndMain::CMSVersion()}

Path manipulation helpers

Represents a class with a local cache which normally invalidates itself between requests.

Handle a callable object as a discoverer

Implements the composite over flush discoverers

Checks whether a filesystem resource has been changed since the manifest generation

Public interface for startup flush discoverers

The default flush discovery implementation

Checks the manifest cache for flush being scheduled in a previous request

Guesses location for temp folder

This is the controller that finds, checks and process all crontasks

Record status of each cron task execution

By implementing this interface a /dev/cron will be able to start in on the expression that you return frmo getSchedule();

Backtrace helper

Interface for a generic build task. Does not support dependencies. This will simply run a chunk of code when called.

A base for bulk loaders of content into the SilverStripe database.

Encapsulates the result of a {@link BulkLoader} import (usually through the {@link BulkLoader->processAll()} method).


Class to facilitate command-line output.

CSSContentParser enables parsing & assertion running of HTML content via CSS selectors.

A basic HTML wrapper for stylish rendering of a development info view.

Constraint for checking if a SS_List contains items matching the given key-value pairs.

Constraint for checking if a SS_List contains only items matching the given key-value pairs. Each match must correspond to 1 distinct record.

Constraint for checking if every item in a SS_List matches a given match, e.g. every Member has isActive set to true

Constraint for checking if a ViewableData (e.g. ArrayData or any DataObject) contains fields matching the given key-value pairs.

Utility class to facilitate complex CSV-imports by defining column-mappings and custom converters.

Supports debugging and core error handling.

A basic HTML wrapper for stylish rendering of a development info view.

Handles raising an notice when accessing a deprecated method, class, configuration, or behaviour.

Outputs the full configuration.

A simple controller using DebugView to wrap up the confirmation form with a template similar to other DevelopmentAdmin endpoints and UIs

Base class for development tools.

A blueprint on how to create instances of a certain {@link DataObject} subclass.

Manages a set of database fixtures for {@link DataObject} records as well as raw database table rows.

SilverStripe-specific testing object designed to support functional testing of your web app. It simulates get/post requests, form submission, and can validate resulting HTML, looking up content by CSS selector.

This class keeps track of the available database adapters and provides a meaning of registering community built adapters in to the installer process.

Interface for database helper classes.

This is a helper class for the SS installer.

A migration task is a build task that is reversible.

A custom exporter for prettier formatting of SilverStripe specific Objects in PHPUnit's failing test messages.

Test case class for the Silverstripe framework.

Manages illegal and required extensions for sapphiretest

Clears flushable / resettable objects

Cleans up and reset global env vars between tests

Handles nesting of kernel before / after tests

Disables any user configured loggers by pushing a NullHandler during PHPUnit tests.

Helper for resetting, booting, or cleaning up test state.

Cleans up leftover databases from aborted test executions (starting with ss_tmpdb) Task is restricted to users with administrator rights or running through CLI.

Collects i18n strings

Kernel for running unit tests

Classes that implement TestOnly are only to be used during testing

Represents a test usage session of a web-app It will maintain session-state from request to request

Hook up static validation to the deb/build process

Basic validation of relationship setup, this tool makes sure your relationships are set up correctly in both directions The validation is configurable and inspection can be narrowed down by namespace, class and relation name

Uses Symfony's YAML component to parse a YAML document (see

DocumentImporterField is built on top of UploadField to access a document conversion capabilities. The original field is stripped down to allow only uploads from the user's computer, and triggers the conversion when the upload is completed.

Utility class hiding the specifics of the document conversion process.

Provides a document import capability through the use of an external service.

Readonly version of a {@link BlockLinkField} field, which displays the data fields as readonly text inputs and a checkbox for "target blank".

A DBLink field will be stored as serialised JSON, and contain link information presented via a "insert link" modal popup, similar to those used in TinyMCE.

Check cache headers for any response, can specify directives that must be included and also must be excluded from Cache-Control headers in response. Also checks for existence of ETag.

Check that the connection to the database is working, by ensuring that the table exists and that the table contains some records.

Check whether the environment setting is safe. Useful for live sites where a non "Live" setting might disclose sensitive information.

Checks that one or more URLs are reachable via HTTP.

Checks for the accessibility and file type validation of one or more files or folders.

Checks for the maximum age of one or more files or folders.

Check that the given file is writable.

Check that the given class exists.

Check that the given function exists.

Checks if the SMTP connection configured through PHP.ini works as expected.

Check that a given URL does not generate a session.

Check the availability of all Solr indexes

Check that a given URL is functioning, by default, the homepage.

Class DevCheckController

Class DevHealthController

Interface for environment checks

Represents a suite of environment checks.

A single set of results from running an EnvironmentCheckSuite

Provides an interface for checking the given EnvironmentCheckSuite.

Factory class for creating HTTP client which are injected into some env check classes. Inject via YAML, arguments for Guzzle client can be supplied using "constructor" property or set as default_config.

Simple helper for env checks which require HTTP clients.

ErrorPage holds the content for the page of an error response.

Controller for ErrorPages.

Enhances error handling for a controller with ErrorPage generated output

Provides {see ErrorPage}-gnostic error handling

Decorates {see File} with ErrorPage support

A Job for running a external link check for published pages

Represents a single link checked for a single run that is broken

Represents a track for a single page

Represents the status of a track run

Content side-report listing pages with external broken links

Check links using curl

Provides an interface for checking that a link is valid

Single checkbox field.

Readonly version of a checkbox field - "Yes" or "No".

Displays a set of checkboxes as a logical group.

Base class for all fields that contain other fields.

CompositeValidator can contain between 0 and many different types of Validators. Each Validator is itself still responsible for Validating its form and generating its ValidationResult.

Two masked input fields, checks for matching passwords.

Renders a text field, validating its input as a currency.

Readonly version of a {@link CurrencyField}.

Readonly version of a {@link CurrencyField}.

Abstract class for all fields without data.

Form used for editing a date string

Disabled version of {@link DateField}.

Form field used for editing date time strings.

Transformation that disables all the fields on the form.

Dropdown field, created from a select tag.

Text input field with validation for correct email format according to RFC 2822.

Lets you include a nested group of fields inside a template.

A list designed to hold form field instances.

Represents a file type which can be added to a form.

Provides operations for reading and writing uploaded files to/from {see File} dataobject instances.

Base class for all forms.

The action buttons are <input type="submit"> as well as

A service which can generate a form

Represents a field in a form.

Form component which contains a castable message

Will convert a SilverStripe message type into a Bootstrap alert type

A helper class for managing {@link Form} and {@link FormField} HTML template output.

This class represents "transformations" of a form - such as making it printable or making it readonly.

Stores GridField action state on an attribute on the action and then analyses request parameters to load it back

Stores GridField action state in the session in exactly the same way it has in the past

Displays a {@link SS_List} in a grid format.

This class is is responsible for adding objects to another object's has_many and many_many relation, as defined by the {@link RelationList} passed to the {@link GridField} constructor.

This component provides a button for opening the add new form provided by {@link GridFieldDetailForm}.

Adding this class to a {@link GridFieldConfig} of a {@link GridField} adds a button row to that field.

Base interface for all components that can be added to GridField.

Encapsulates a collection of components following the {@link GridFieldComponent} interface. While the {@link GridField} itself has some configuration in the form of setters, most of the details are dealt with through components.

A simple readonly, paginated view of records, with sortable and searchable headers.

Allows editing of records contained within the GridField, instead of only allowing the ability to view records in the GridField.

Allows viewing readonly details of individual records.

Similar to {@link GridFieldConfig_RecordEditor}, but adds features to work on has-many or many-many relationships.

This class is a {@link GridField} component that adds a delete action for objects.

Provides view and edit forms at GridField-specific URLs.

Provides the entry point to editing a single record presented by the {@link GridField}.

Adds an "Export list" button to the bottom of a {@link GridField}.

GridFieldFilterHeader alters the {@link GridField} with some filtering fields in the header of each column.

Adding this class to a {@link GridFieldConfig} of a {@link GridField} adds a footer bar to that field.

Adds a delete action for the gridfield to remove a relationship from group.

GridFieldLazyLoader alters the {@link GridField} behavior to delay rendering of rows until the tab containing the GridField is selected by the user.

Adds a "level up" link to a GridField table, which is useful when viewing hierarchical data. Requires the managed record to have a "getParent()" method or has_one relationship called "Parent".

GridFieldPage displays a simple current page count summary.

GridFieldPaginator paginates the {@link GridField} list and adds controls to the bottom of the {@link GridField}.

Adds an "Print" button to the bottom or top of a GridField.

GridFieldSortableHeader adds column headers to a {@link GridField} that can also sort the columns.

A trait that makes a class able to consume and use a {@link GridFieldStateManagerInterface} implementation

Creates a unique key for the gridfield, and uses that to write to and retrieve its state from the request

Defines a class that can create a key for a gridfield and apply its state to a request, and consume state from the request

Adding this class to a {@link GridFieldConfig} of a {@link GridField} adds a header title to that field.

A button that allows a user to view readonly details of a record. This is disabled by default and intended for use in readonly {@link GridField} instances.

Groups exiting actions in the Actions column in to a menu

GridField action menu item interface, this provides data so the action will be included if there is a {see GridField_ActionMenu}

Allows GridField_ActionMenuItem to act as a link

An action is defined by two things: an action name, and zero or more named arguments.

Add a new column to the table display body, or modify existing columns.

Can modify the data list.

This class is the base class when you want to have an action that alters the state of the {@link GridField}, rendered as a button element.

A GridField manipulator that provides HTML for the header/footer rows, or f or before/after the template.

A component which is used to handle when a {@link GridField} is saved into a record.

A GridField component that provides state, notably default state.

Sometimes an action isn't enough: you need to provide additional support URLs for the {@link GridField}.

This class is a snapshot of the current status of a {@link GridField}.

Simple set of data, similar to stdClass, but without the notice-level errors.

Grouped dropdown, using optgroup tags.

A PHP version of TinyMCE's configuration, to allow various parameters to be configured on a site or section basis

A TinyMCE-powered WYSIWYG HTML editor field with image and link insertion and tracking capabilities. Editor fields are created from <textarea> tags, which are then converted with JavaScript.

Readonly version of an {@link HTMLEditorField}.

Sanitises an HTMLValue so it's contents are the elements and attributes that are whitelisted using the same configuration as TinyMCE

Generates tinymce config using a combined file generated via a standard SilverStripe {@link GeneratedAssetHandler}

Default configuration for HtmlEditor specific to tinymce

Declares a service which can generate a script URL for a given HTMLEditor config

Readonly field equivalent for literal HTML

Field that generates a heading tag.

Hidden field.

Simple label, to add extra text in your forms.

Multi-line listbox field, created from a select tag.

This field lets you put an arbitrary piece of HTML into your forms.

Read-only complement of {@link MultiSelectField}.

A form field that can save into a {@link Money} database field.

Represents a SelectField that may potentially have multiple selections, and may have a {@link ManyManyList} as a data source.

NullableField is a field that wraps other fields when you want to allow the user to specify whether the value of the field is null or not.

Text input field with validation for numeric values. Supports validating the numeric value as to the {@link i18n::get_locale()} value, or an overridden locale specific to this field.

Set of radio buttons designed to emulate a dropdown.

Password input field.

Popup form action menu for "more options"

Transformation that will make a form printable.

Class representing printable tabsets

Read-only field to display a non-editable value with a label.

Transformation that will turn a form into a readonly version of itself

Required Fields allows you to set which fields need to be present before submitting the form. Submit an array of arguments or each field as a separate argument.

Represents a {@link Form} as structured data which allows a frontend library to render it.

Represents a field that allows users to select one or more items from a list

Represents a number of fields which are selectable by a radio button that appears at the beginning of each item. Using CSS, you can configure the field to only display its contents if the corresponding radio button is selected. Each item is defined through {@link SelectionGroup_Item}.

Read-only complement of {@link DropdownField}.

Represents the base class for a single-select field


Implements a single tab in a {@link TabSet}.

Defines a set of tabs in a form.

Text input field.

TextareaField creates a multi-line text field, allowing more data to be entered than a standard text field. It creates the <textarea> tag in the form HTML.

Form field to display editable time values in an field.

The readonly class for our {@link TimeField}.


Represents a Tip which can be rendered alongside a form field in the front-end.

Declares that a form field has the ability to accept and render Tips.

Allows visibility of a group of fields to be toggled.

Dropdown-like field that allows you to select an item from a hierarchical AJAX-expandable tree.

This formfield represents many-many joins using a tree selector shown in a dropdown styled element which can be added to any form usually in the CMS.

Represents a form field which has an Upload() instance and can upload to a folder

This validation class handles all form and custom form validation through the use of Required fields. It relies on javascript for client-side validation, and marking fields after server-side validation. It acts as a visitor to individual form fields.

An AuthenticatorInterface is responsible for authenticating against a SilverStripe CMS Member from the given request data.

An authenticator using SilverStripe's BasicAuth

The authentication Handler is responsible for handling authentication requirements and providing a Member to the Manager if required, so it can be used in request contexts.

Top level controller for handling graphql requests.

Attaches itself to {see DataQuery} and records any classes that are queried within a closure context.

Adds functionality that checks a request for a token before allowing a mutation to happen. Protects against CSRF attacks

Ensures mutations use POST requests

Represents middleware for evaluating a graphql query

Allows any class to hold Member state

Class FileProvider

Class HTTPProvider

Class ConfigStringProvider

Implementations of query persistence must use this interface. At a minimum, they must be able to fetch a query given an ID.

Implementations of query persistence must use this interface. At a minimum, they must be able to fetch a query given an ID.

Throws everything, including notices, so the JSON response doesn't get corruped by E_NOTICE, E_WARN outputs.

An exception that was thrown during execution of a query

This class is responsible for taking query information from a controller, processing it through middlewares, extracting the results from the GraphQL schema, and formatting it into a suitable JSON response.

Query handlers are responsible for applying a query as a string to a Schema object and returning a result.

Provides an arbitrary state container that can be passed through the resolver chain. It is empty by default and derives no state from the actual schema

Provides base functionality to all bulk loaders. Should override the collect() method with computations that parse the include/exclude directives and return a collection of classes.

Composed with a list of bulk loaders to be executed in serial and return the aggregate result of all their collect() calls

Defines a collection of class names paired with file paths

Loads classes that have a given extension assigned to them.

Loads classes by fuzzy match (glob), relative to the root e.g. src/*.model.php

Loads classes that are in a given inheritance tree, e.g. MyApp\Models\Page

Loads classes based on fuzzy match of FQCN, e.g. App\Models*

Frontend for creating a cached registry instance based on all the qualifying subclasses.

The instance of the registry, as composed by the Registry frontend

Used for unions and interfaces to map a class instance to a type

Creates a "create" mutation for a DataObject

Defines the model that generates types, queries, and mutations based on DataObjects

Creates a delete operation for a DataObject

A utility class that handles an assortment of issues related to field access on DataObjects, particularly with case insensitivity.

A schema-aware service for DataObject model types that builds out their inheritance chain in an ORM-like way, applying inherited fields and implicitly exposing ancestral types, etc.

Utility class that abstracts away class ancestry computations and creates an inheritance "type" for a DataObject

A schema-aware services for DataObject model types that creates union types for all the members of an inheritance chain. Can also apply these unions to queries to enforce unions when return types have descendants.

A schema-aware service for DataObject model types that emulates class inheritance by capturing groups of common fields into interfaces and applying one or many interfaces to concrete model types. Also creates a "base" interface for fields common to all DataObjects (i.e. "extends DataObject" pattern)

Creates a model for a DataObject

Defines a permission checking plugin for queries. Subclasses just need to provide a resolver function

A permission checking plugin for DataLists

Defines a set of arguments that applies to a field that maps to a DBField.

Adds inheritance fields to a DataObject type, and exposes its ancestry

Ensures DataObject models merge their plugins with ancestors

Adds pagination to a DataList query

Defines the interface used by all read filters for operations

Filters for queries are registered as services and retrieved by identifiers.

A filter that selects records that partially match a keyword

A query filter that filters records by the end of a field's contents

A query filter that filters records by exact match of a keyword

A query filter that filters records by greater than comparison

A query filter that filters records by greater than or equal comparison

A query filter that filters records by the presence of a value in an array

A query filter that filters records by a less than comparison

A query filter that filters records by a less than or equal comparison

A query filter that filters records by negating an exact match

A query filter that filters records by the start of a field's content

A special type of filter that accepts list values

Adds a filter parameter to a DataObject query

Adds a sort parameter to a DataObject query

Ensures any field that ends up as ViewableData, e.g. DBField, invokes forTemplate() after resolving.

Creates a read operation for a DataObject

Creates a readOne query for a DataObject

Generic resolver for DataObjects

Creates an update operation for a DataObject

Thrown when a mutation operation fails

Thrown when an operation encounters a permissions problem, e.g. lack of read/write permissions

Captures a failure that happened within a resolver. Designed to add context to the failure, as a chain of closures in a nested query can be very hard to debug.

The primary exception thrown by the Schema and its components. Used whenever the schema is put into a state where it cannot build a valid schema.

An abstraction of a field argument

An abstraction of a field that appears on a Type abstraction

Used for a variety of classes that rely on SchemaModelInterface

A field that appears on model type

Defines a mutation created by a model

Defines a query generated by a model

Defines a generic mutation

Defines a generic query

Defines a model that provides required fields for all the types it creates

Applies an array of config to a class

A class that can store a generic array of context

For models that can provide a default set of fields

A class that is capable of expressing itself in generated code

For models that provide extra types to the schema

A plugin that applies to a Field abstraction

Used by any class that declares an identifier

Implementors of this interface provide input types back to the schema

Implementors of this interface can prevent a given set of fields from being added

A plugin that applies only to mutations created by models

Applies to an operation that was crated by a model

A plugin that applies only to queries generated by models

A plugin that only applies to types generated by models

A plugin that applies to a generic mutation

Implementors of this interface can create queries and mutations dynamically

Implementors of this interface provide a lookup for operations by identifiers

Base plugin interface. There is a lot of "duck programming" happening in this API that will go away once we have better type variance in PHP 7.4:

Validates that a given plugin is acceptable for the implementing class

A plugin that is used for a generic query

Implementors of this class can create a model for a given classname, e.g. Blog -> DataObjectModel

Implementors of this interface can be models that generate types and operations

Given a name, create a SchemaStorageInterface implementation

Persists a graphql-php Schema object, and retrieves it

Implementors of this interface can make a one-time, context-free update to the schema, e.g. adding a shared Enum type

Implementors of this class that can validate that they are ready to be encoded into the schema

Any class that can represent its state as a string. Kind of like serialize, but doesn't need to support unserialization

A plugin that applies to a generic Type

Generic plugin that can be used for filter inputs

Generic plugin that can be used to add sort paramaters to a query

Generic pagination functionality for a query that can be customised in subclasses

Allows adding, loading, and sorting of plugins

A central place for all the plugins to be registered and accessed by ID

Given a stack of resolver middleware and afterware, compress it into one composed function, passing along the return value.

Default field resolver for any type

A good starting point for a resolver discovery implementation.

A resolver function that can be expressed in generated PHP code

A uniform way of referring to a resolver callable. Normalises the string/array variants

The main Schema definition. A docking station for all type, model and interface abstractions.

Encapsulates configuration required for a {@link Schema} object.

An agnostic service that builds an input type based on a given field, with nesting.

Persists a graphql schema to a json document consumable by Apollo

A readonly value object that represents a schema in its final consumable state. It knows nothing about models or operations, plugins, or all the abstractions surrounding how the schema gets defined

For the most obscure approach, hash the file names so they're highly undiscoverable in IDE search

Hashed for less discoverability, but still readable if you focus on it

Naive implementation for debugging. Allow the class file name to be the same as the class

Defines a service that can obfuscate classnames to make their files less discoverable in IDE Search

A type that can be expressed as generated PHP code

Abstraction for enum types

Abstraction that can express input types as code

Defines a GraphQL interface. It may seem counter-intuitive that an abstraction would inherit from the concretion, but since these are just value objects that end up getting rendered as code, an unconventional architecture is probably okay. The irrelevant fields just just ignored in rendering.

Defines an interface that is backed by a model

A type that is generated by a model

Defines a union that is backed by a model definition

Abstraction for a generic type

Uniform way of referring to a type as a string. Accepts default value syntax

Abstraction of a union type

Adjusts UserDefinedForm to use GridFieldQueuedExportButton instead of GridFieldExportButton (the default)

A button you can add to a GridField to export that GridField as a CSV. Should work with any sized GridField, as the export is done using a queuedjob in the background.

A special type of SS_HTTPResponse that GridFieldQueuedExportButton returns in response to the "findgridfield" action, which includes a reference to the gridfield

Iteratively exports GridField data to a CSV file on disk, in order to support large exports.

Some cryptography used for Session cookie encryption.

A session store which stores the session data in an encrypted & signed cookie.

Iframe page type embeds an iframe of URL of choice into the page.

Class LDAPAuthenticator

Class LDAPDebugController

Class LDAPGroupExtension

Class LDAPMemberExtension.

Class LDAPLoginForm

Class LDAPIterator

Class LDAPAllSyncJob

Class LDAPMemberSyncJob

Class LDAPGateway

Class LDAPGroupMapping

Class LDAPUtil

Class LDAPService

Class LDAPGroupSyncTask

Class LDAPMemberSyncOneTask

Class LDAPMemberSyncTask

Class LDAPMigrateExistingMembersTask

Produce a friendly error message

Monolog-compatible error handler that will output a detailed error message to the screen.

Core error handler for a SilverStripe application

Output the error to the browser, with the given HTTP status code.

Applies to the {see Security} controller in order to detect requests for actions related to the log in process or other such credential management (such as the forgot password flow).

GridField config necessary for managing a SiteTree object.

This component creates a dropdown of possible page types and a button to create a new page.

Swaps the GridField Link out for the SiteTree edit link using {@link SiteTree::CMSEditLink()}.

Provides a component to the {@link GridField} which shows the publish status of a page.

Class Lumberjack

Extends the "MemberAuthenticator version of the ChangePasswordHandler in order to allow MFA to be inserted into the flow when an AutoLoginHash is being used - that is when the user has clicked a reset password link in an email after using the "forgot password" functionality.

This controller handles actions that a user may perform on MFA methods registered on their own account while logged in. This includes deleting methods, registering new methods and replacing (re-registering) existing methods.

Clears any user defined loggers during unit test execution

Representing a failure during encryption or decryption with an EncryptionAdapterInterface

A member was not found when one was expected to exist

Handles removing a member's registered MFA methods during Account Reset. Also resets the 'MFA Skipped' flag on the member so that they are prompted to set up MFA again when they next log in.

Provides DB columns / methods for account resets on Members

This extension is applied to SecurityAdmin to provide an additional endpoint for sending account reset requests.

Extends the Security controller to support Account Resets. This extension can itself be extended to add procedures to the reset action (such as removing additional authentication factors, sending alerts, etc.)

Extend Member to add relationship to registered methods and track some specific preferences

Adds multi-factor authentication related settings to the SiteConfig "Access" tab

Provides a simplified method for creating JSON-based HTTPResponses.

Represents the base requirements for implementing an MFA Method's RegisterHandler, which has the responsibility of initiating and managing registration of the MFA Method in question against the current Member.

Define how MFA Methods will initiate and check verification attempts.

Defines an Authentication Method, which serves as an additional factor for authentication beyond the standard username / password method.

This trait encapsulates logic that can be added to a RequestHandler to work with registering MFA authenticators using the MFA front-end app. It provides two main methods; see createStartRegistrationResponse - creates a response that can be easily consumed by the MFA app to start the registration process for a method, and

This trait encapsulates logic that can be added to a RequestHandler to work with logging in using MFA front-end app. It provides two main methods; see createStartVerificationResponse - a response that can be easily consumed by the MFA app to prompt a login, and see completeVerificationRequest - used to verify a request sent by the MFA app containing the login attempt.

A service class implementation for generating and hashing backup codes.

An encryption adapter for defuse/php-encryption, enabled by default.

A generic encryption service implementation, responsible for encrypting and decrypting strings.

The EnforcementManager class is responsible for making decisions regarding multi-factor authentication app flow, e.g. "should we redirect to the MFA section", "can the user skip MFA registration" etc.

A service class that holds the configuration for enabled MFA methods and facilitates providing these methods

Encapsulates setting up an Email in order to allow for dependency injection and to avoid introducing a hard coupling to the SilverStripe core Email class in code that consumes this class.

The RegisteredMethodManager service class facilitates the communication of Members and RegisteredMethod instances in a reusable singleton.

Generates a multi-factor authentication frontend app schema from the given request

Used to provide details about an available {@link \SilverStripe\MFA\Method\MethodInterface} instance, for example when being used in the multi-factor application schema.

A container for a backup code and its hash, normally used during backup code generation

Used to provide details about a registered {@link \SilverStripe\MFA\Method\MethodInterface} instance, for example when being used in the multi-factor application schema.

An immutable result object often detailing the result of a registration or validation completed by the respective handlers

This class provides an interface to store data in session during an MFA process. This is implemented as a measure to prevent bleeding state between individual MFA auth types

Represents a place for temporarily storing state related to a login or registration attempt.

Adds an additional validation rule to Upload_Validator that attempts to detect the file extension of an uploaded file matches it's contents, which is done by detecting the MIME type and doing a fuzzy match.

Library of static methods for manipulating arrays.

A list object that wraps around an array of objects or arrays.

Interface to provide enough information about a record to make it previewable through the CMS. It uses the record database ID, its "frontend" and "backend" links to link up the edit form with its preview.

Represents an object responsible for wrapping DB connector api

Builds a SQL query string from a SQLExpression object

Represents and handles all schema management for a database

Abstract database connectivity class.

Error class for database exceptions

MySQL connector class.

A result-set from a MySQL database (using MySQLiConnector) Note that this class is only used for the results of non-prepared statements

Builds a SQL query string from a SQLExpression object

Represents schema management object for MySQL

Provides a record-view for mysqli prepared statements

TransactionManager that executes MySQL-compatible transaction control queries

Connector for MySQL using the MySQLi method

TransactionManager decorator that adds virtual nesting support.

Abstract query-result class. A query result provides an iterator that returns a map for each record of a query result.

Represents an object that is capable of controlling transactions.


Global database interface, complete with static methods.

An extension that adds additional functionality to a {@link DataObject}.

Implements a "lazy loading" DataObjectSet.

A single database record & abstract class for the data-access-model.

DataObjectInterface is an interface that other data systems in your application can implement in order to behave in a manner similar to DataObject.

Provides dataobject and database schema mapping functionality

An object representing a query of data from the DataObject's supporting database.

Allows middleware to modily finalised dataquery on a per-instance basis

Represents a subgroup inside a WHERE clause in a {@link DataQuery}

DatabaseAdmin class

Represents a signed 8 byte integer field. Do note PHP running as 32-bit might not work with Bigint properly, as it would convert the value to a float when queried from the database since the value is a 64-bit one.

Represents a boolean field.

Represents a classname selector, which respects obsolete clasess.

Extend this class when designing a {@link DBField} that doesn't have a 1-1 mapping with a database field.

Represents a decimal field containing a currency amount.

Represents a date field.

Represents a date-time field.

Represents a Decimal field.

Supports double precision DB types

Class Enum represents an enumeration of a set of strings.

Single field in the database.

Represents a floating point field.

A special type Int field used for foreign keys in has_one relationships.

Represents a large text field that contains HTML content.

Represents a short text field that is intended to contain HTML content.

Classes that implement the DBIndexable interface will provide options to set various index types and index contents, which will be processed by {@link \SilverStripe\ORM\DataObjectSchema}

Represents a signed 32 bit integer field.

Locale database field

Provides storage of a localised money object in currency and amount components.

Represents an multi-select enumeration field.

Represents a decimal field from 0-1 containing a percentage value.

A special ForeignKey class that handles relations with arbitrary class types

A special type Int field used for primary keys.

An abstract base class for the string field types (i.e. Varchar and Text)

Represents a variable-length string of up to 16 megabytes, designed to store raw text

Represents a column in the database with the type 'Time'.

Class Varchar represents a variable-length string of up to 255 characters, designed to store raw text

Represents a single year field.

Additional interface for {@link SS_List} classes that are filterable.

Base class for creating comparison filters, eg; greater than, less than, greater than or equal, etc

Matches textual content with a substring match on a text fragment leading to the end of the string.

Selects textual content with an exact match between columnname and keyword.

Filters by full-text matching on the given field.

Selects numerical/date content greater than the input

Selects numerical/date content greater than or equal to the input

Selects numerical/date content less than the input

Selects numerical/date content less than or equal to the input

Matches textual content with a LIKE '%keyword%' construct.

Base class for filtering implementations, which work together with {@link SearchContext} to create or amend a query for {@link DataObject} instances.

Matches textual content with a substring match from the beginning of the string.


A list decorator that allows a list to be grouped into sub-lists by common values of a field.

Subclass of {@link DataList} representing a has_many relation.

Anything that implements HiddenClass won't be shown in user-interface elements. For example, DataObjects that implement HiddenClass won't be showing in the "new page" dropdown.

DataObjects that use the Hierarchy extension can be be organised as a hierarchy, with children and parents. The most obvious example of this is SiteTree.

Contains a set of hierarchical objects generated from a marking compilation run.

Additional interface for {@link SS_List} classes that are limitable - able to have a subset of the list extracted.

Subclass of {@link DataList} representing a many_many relation.

ManyManyList backed by a dataobject join table

Injected into DataQuery to augment getFinalisedQuery() with a join table


Creates a map from an SS_List by defining a key column and a value column.

A decorator that wraps around a data list in order to provide pagination.

Represents a has_many list linked against a polymorphic relationship

Represents a list of updates / inserts made to a single row in a table

Represents a where condition that is dynamically generated. Maybe be stored within a list of conditions, altered, and be allowed to affect the result of the parent sql query during future execution.

Represents a SQL query for an expression which interacts with existing rows (SELECT / DELETE / UPDATE) with a WHERE clause

Object representing a SQL DELETE query.

Abstract base class for an object representing an SQL query.

Object representing a SQL INSERT query.

Object representing a SQL SELECT query.

Object representing a SQL UPDATE query.

Represents a SQL expression which may have field values assigned (UPDATE/INSERT Expressions)

Abstract representation of a DB relation field, either saved or in memory

A DataList that represents a relation.

An interface that a class can implement to be treated as a list container.

Provides a simple search engine for your site based on the MySQL FULLTEXT index.

Manages searching of properties on one or more {@link DataObject} types, based on a given set of input parameters.

Additional interface for {@link SS_List} classes that are sortable.

Throw this exception whenever unexpected data is found.

Interface UniqueKeyInterface

Class UniqueKeyService

An {@link ArrayList} that represents an unsaved relation.

Exception thrown by {@link DataObject}::write if validation fails. By throwing an exception rather than a user error, the exception can be caught in unit tests and as such can be used as a successful test.

A class that combined as a boolean result with an optional list of error messages.

Class RealMeAuthenticator

Class MemberExtension

Class RealMeFederatedIdentity

Class RealMeUser

Class RealMeSetupTask

Base "abstract" class creating reports on your data.

Reports section of the CMS.

SS_ReportWrapper is a base class for creating report wappers.

Renderer for showing SideReports in CMSMain

A report wrapper that makes it easier to define slightly different behaviour for side-reports.

A simple authenticator for the Restful server.

A DataFormatter object handles transformation of data from SilverStripe model objects to a particular output format, and vice versa. This is most commonly used in developing RESTful APIs.

Accepts form encoded strings and converts them to a valid PHP array via {@link parse_str()}.

Formats a DataObject's member fields into a JSON string

Formats a DataObject's member fields into an XML string

Generic RESTful server, which handles webservice access to arbitrary DataObjects.

Restful server handler for a single DataObject

Restful server handler for a SS_List

An extension to GridFieldExportButton to support downloading a custom Report as a CSV file

An extension to GridFieldPrintButton to support printing custom Reports

Extends the {see Member} class with additional descriptions for elements.

Adds 'SubsiteDescription' for to show which subsites this Member has edit access to

User Security Report

An AuthenticationHandler is responsible for providing an identity (in the form of a Member object) for a given HTTPRequest.

Abstract base class for an authentication method

Provides an interface to HTTP basic authentication.

Provides a security interface functionality within the cms

Basic confirmation form implementation.

Confirmation form handler implementation

Confirmation item is a simple data object incapsulating a single confirmation unit, its unique identifier (token), its human friendly name, description and the status whether it has already been confirmed.

Confirmation Storage implemented on top of SilverStripe Session and Cookie

Provides access to the default admin

Allows objects to enforce permissions for the "root" level, where permissions can not be tied to a particular database record.

A security group.

Represents an authentication handler that can have identities logged into & out of it.

Calculates batch permissions for nested objects for:

  • canView: Supports 'Anyone' type
  • canEdit
  • canDelete: Includes special logic for ensuring parent objects can only be deleted if their children can be deleted also.

Provides standard permission fields for inheritable permissions

Record all login attempts through the {@link LoginForm} object.

Abstract base class for a login form

Log out form to display to users who arrive at 'Security/logout' without a CSRF token. It's preferable to link to {@link Security::logout_url()} directly - we only use a form so that we can preserve the "BackURL" if set

The member class which represents the users of the system

Provides authentication for the user within the CMS

Provides the in-cms session re-authentication form for the "member" authenticator

Standard Change Password Form

Authenticate a member passed on a session cookie

Handle login requests from MemberLoginForm

Class LogoutHandler handles logging out Members from their session and/or cookie.

Class LostPasswordForm handles the requests for lost password form generation

Handle login requests from MemberLoginForm

Authenticator for the default "member" method

Log-in form for the "member" authentication method.

Authenticate a member passed on a session cookie

Imports member records, and checks/updates duplicates based on their 'Email' property.

Keep track of users' previous passwords, so that we can check that new passwords aren't changed back to old ones.

Represents a set of Groups attached to a member.

Member Validator

Specialized subclass for disabled security tokens - always returns TRUE for token checks. Use through {@link SecurityToken::disable()}.

Allows pluggable password encryption.

Blowfish encryption - this is the default from SilverStripe 3.

Legacy implementation for SilverStripe 2.1 - 2.3, which had a design flaw in password hashing that caused the hashes to differ between architectures due to floating point precision problems in base_convert().

Uses MySQL's OLD_PASSWORD encyrption. Requires an active DB connection.

Uses MySQL's PASSWORD encryption. Requires an active DB connection.

Cleartext passwords (used in SilverStripe 2.1).

Encryption using built-in hash types in PHP.

Check if authenticated user has password expired.

This class represents a validator for member passwords.

Represents a permission assigned to a group.

Shows a categorized list of available permissions (through {@link Permission::get_codes()}).

Readonly version of a {@link PermissionCheckboxSetField} - uses the same structure, but has all checkboxes disabled.

Calculates edit / view / delete permissions for one or more objects

Throw this exception to register that a user doesn't have permission to do the given action and potentially redirect them to the log-in page. The exception message may be presented to the user, so it shouldn't be in nerd-speak.

Used to let classes provide new permission codes.

A PermissionRole represents a collection of permission codes that can be applied to groups.

A PermissionRoleCode represents a single permission code assigned to a {@link PermissionRole}.

Permission_Group class

Convenience class for generating cryptographically secure pseudo-random strings/tokens

Persists a token associated with a device for users who opted for the "Remember Me" feature when logging in.

Core authentication handler / store

Implements a basic security model

Cross Site Request Forgery (CSRF) protection for the {@link Form} class and other GET links.

A service class responsible for activating and checking the current status of elevated permission levels via "sudo mode". This is done by checking a timestamp value in the provided session.

Handles session revocation AJAX request

Augment Member to allow relationship to the LoginSession DataObject

Tracks a login session for a specific user on a specific device.

This is separate to LogOutAuthenticationHandler so that it can be registered with Injector and called after the other AuthenticationHandler::logIn() implementations

This is separate to LogInAuthenticationHandler so that it can be registered with Injector and called before the other AuthenticationHandler::logOut() implementations

Remove expired share tokens.


Root permission provider for pages in the SiteTree root

Class GridFieldBasicContentReport

Provides contentreview integration for sitewide content report.

Provides subsite integration for sitewide content report.

Provides taxonomy integration for sitewide content report.

Content side-report listing all pages and files from all sub sites.

Editable Spam Protecter Field. Used with the User Defined Forms module (if installed) to allow the user to have captcha fields with their custom forms

Apply the spam protection to the comments module if it is installed.

An extension to the {@link Form} class which provides the method {@link enableSpamProtection()} helper.

SpamProtector base interface.

Describes an object that may wish to trigger updates in other objects as a result of it's own update.

This extension couples to the StaticallyPublishable and StaticPublishingTrigger implementations on the SiteTree objects and makes sure the actual change to SiteTree is triggered/enqueued.

Bare-bones implementation of a publishable page.


Class Job

Class DeleteStaticCacheJob remove pages from static cache based on list of URLs

Class GenerateStaticCacheJob add pages to static cache based on list of URLs

Class StaticCacheFullBuildJob

Class UrlBundleService

Admin interface to manage and create {@link Subsite} instances.

Section-agnostic PJAX controller.

Extension for the File object to add subsites support

Extension for the Group object to add subsites support

This extension adds the current Subsite ID as an additional factor to the Hints C├čache Key, which is used to cache the Site Tree Hints (which include allowed pagetypes).

Decorator designed to add subsites support to LeftAndMain

Extension for the SiteConfig object to add subsites support

Extension for the SiteTree object to add subsites support

Wraps around a TreedropdownField to add ability for temporary switching of subsite sessions.

A text field that accepts only valid domain names, but allows the wildcard (*) character

A dynamically created subsite. SiteTree objects can now belong to a subsite.

Creates a subsite-aware version of another report.

SubsiteState provides static access to the current state for subsite related data during a request

Handy alternative to copying pages when creating a subsite through the UI.

Enables time-based one-time password (TOTP) authentication for the silverstripe/mfa module.

Handles registration requests using a time-based one-time password (TOTP) with the silverstripe/mfa module.

Handles verification requests using a time-based one-time password (TOTP) with the silverstripe/mfa module.

A readonly extension of TagField useful for non-editable items within the CMS.

Provides a tagging interface, storing comma-delimited tags in a DataObject string field.

Provides a tagging interface, storing links between tag DataObjects and a parent DataObject.

Class TaxonomyDirectoryController

Management interface for Taxonomies, TaxonomyTerms and TaxonomyTypes

Represents a single taxonomy term. Can be re-ordered in the CMS, and the default sorting is to use the order as specified in the CMS.

Represents a type of taxonomy, which can be configured in the CMS. This can be used to group similar taxonomy terms together.

Uses SS_Cache with a lifetime to cache extracted content

Caches the extracted content on the record for the file.

Decorate File or a File derivative to enable text extraction from the file content. Uses a set of subclasses of FileTextExtractor to do the extraction based on the content type of the file.

A decorator for File or a subclass that provides a method for extracting full-text from the file's external contents.

Text extractor that uses php function strip_tags to get just the text. OK for indexing, not the best for readable text.

Text extractor that calls pdftotext to do the conversion.

Text extractor that calls an Apache Solr instance and extracts content via the "ExtractingRequestHandler" endpoint.

Enables text extraction of file content via the Tika Rest Server

Enables text extraction of file content via the Tika CLI

Provides a few endpoints the user form CMS UI targets with some AJAX request.

Controller for the {@link UserDefinedForm} page type.

Update DataObjects on the file "Used On" table

Represents a composite field group, which may contain other groups

Represents a field container which can iteratively process nested fields, converting it into a fieldset

A list of formfields which allows for iterative processing of nested composite fields

Front end composite field for userforms

Represents a page step in a form, which may contain form fields or other groups

A button which allows objects to be created with a specified classname(s)

Extension to the build in SilverStripe {@link GridField} to allow for filtering {@link SubmittedForm} objects in the submissions tab by entering the value of a field

An extension of RequiredFields which handles conditionally required fields.

A custom rule for showing / hiding an EditableFormField based the value of another EditableFormField.

Represents the base class of a editable form field object like {@link EditableTextField}.



A dropdown field which allows the user to select a country




Specifies that this ends a group of fields

Specifies that this ends a group of fields

Allows a user to add a field that can be used to upload a file.

Allows an editor to insert a generic heading into a field

A step in multi-page user form

Editable Literal Field. A literal field is just a blank slate where you can add your own HTML / Images / Flash

Creates an editable field that displays members in a given group

Base class for multiple option fields such as {@link EditableDropdownField} and radio sets.


Base Class for EditableOption Fields such as the ones used in dropdown fields and in radio check box groups



A Form can have multiply members / emails to email the submission to and custom subjects

Declares a condition that determines whether an email can be sent to a given recipient

Controller that handles requests to EmailRecipient's

A file uploaded on a {@link UserDefinedForm} and attached to a single {@link SubmittedForm}.

Data received from a UserDefinedForm submission

UserForms Column Clean Task

Defines the user defined functionality to be applied to any {@link DataObject}

Caches results of a callback

Conditionally executes a given callback, attempting to return the desired results of its execution.

Provides rate limiting of execution of a callback

Allows global configuration of all changes

Archive admin is a section of the CMS that displays archived records from versioned objects and allows for users to restore them.

The history viewer controller uses the React based {@link HistoryViewerField} to display the history for a {@link DataObject} that has the {@link Versioned} extension.

The HistoryViewerController provides AJAX endpoints for React to enable functionality, such as retrieving the form schema.

Adds a restore action to the item edit form of ArchiveAdmin

Adds a archive view for Elemental blocks

Adds a archive view for Files

Adds a archive view for Pages

This form field is both a field object in it's own right, and a decorator for another field type.

Extension of GridFieldRestoreAction to only show action if there is a valid file

A provider of a view for the archive admin

psr-6 cache proxy for an internal cache, which provides segmentation of cache keys based on current versioned mode. This ensures that cross-stage content cannot cross-pollenate each other.

Allows injection of a psr-6 proxy over an inner cache backend.

The ChangeSet model tracks several VersionedAndStaged objects for later publication as a single atomic action

A single line in a changeset

Utility class to render views of the differences between two data objects (or two versions of the same data object).

Decorates TestSession object to update get / post requests with versioned querystring arguments.

Decorate sapphire test with versioning

Scaffolds a generic update operation for DataObjects.

Scaffolds a "copy to stage" operation for DataObjects.

Scaffolds a generic update operation for DataObjects.

Scaffolds a "rollback recursive" operation for DataObjects.

Scaffolds a generic update operation for DataObjects.

This class is a {@link GridField} component that replaces the delete action and adds an archive action for objects.

This class is a {@link GridField} component that adds a restore action for versioned objects.

Converter helpers for versioned args

Provides owns / owned_by and recursive publishing API for all objects.

Provides recursive publishable behaviour for LeftAndMain and GridFieldDetailForm_ItemRequest

Generic restore action to restore an archived item to draft

Minimum level extra fields required by extensions that are versonable

The Versioned extension allows your DataObjects to have several versions, allowing you to rollback changes and view history. An example of this is the pages used in the CMS.

Decorates a GridFieldConfig with a archive action

Extends {see GridFieldDetailForm}

Provides versioned dataobject support to {see GridFieldDetailForm_ItemRequest}

Decorates a GridFieldConfig with gridfield publishing state

Initialises the versioned stage when a request is made.

Persists versioned state between requests via querystring arguments

Applies correct stage to tables

Represents a single version of a record.

Lets you wrap a bunch of array data, or object members, into a {@link ViewableData} object.

This trait can be applied to a ViewableData class to add the logic to render attributes in an SS template.

Resets requirements for test state

This class acts as a wrapper around the third party requirement embed/embed v4

Abstract interface for an embeddable resource

HTML Helper class

A FilterInterface is given an input string and returns a filtered string. Replacements will be provided and performed (typically in regex format), and transliteration may be used as a separate service to replace characters rather than remove them.

Base class for HTML cleaning implementations.

This class handles the converting of HTML fragments between a string and a DOMDocument based representation.

Class representing a 'diff' between two sequences of HTML strings.

Cleans HTML using the HTMLPurifier package

Format a SQL Query for better readable output in HTML or Plaintext.

Abstract interface for a class which handles shortcodes

A simple parser that allows you to map BBCode-like "shortcodes" to an arbitrary callback.

Cleans HTML using the Tidy package

Support class for converting unicode strings into a suitable 7-bit ASCII equivalent.

Filter certain characters from "URL segments" (also called "slugs"), for nicer (more SEO-friendly) URLs.

Requirements tracker for JavaScript and CSS.

This is the exception raised when failing to parse a template. Note that we don't currently do any static analysis, so we can't know if the template will run, just if it's malformed. It also won't catch mistakes that still look valid.

This is the parser for the SilverStripe template language. It gets called on a string and uses a php-peg parser to match that string against the language structure, building up the PHP code to execute that structure as it parses

Parses a template file with an *.ss file extension.

Defines an extra set of basic methods that can be used in templates that are not defined on sub-classes of {@link ViewableData}.

This extends SSViewer_Scope to mix in data on top of what the item provides. This can be "global" data that is scope-independant (like BaseURL), or type-specific data that is layered on top cross-cut like (like $FirstLast etc).

Special SSViewer that will process a template passed as a string, rather than a filename.

This tracks the current scope for an SSViewer instance. It has three goals:

  • Handle entering & leaving sub-scopes in loops and withs
  • Track Up and Top
  • (As a side effect) Inject data that needs to be available globally (used to live in ViewableData)

Provider for the [embed] shortcode tag used by the embedding service in the HTML Editor field.

Interface that is implemented by any classes that want to expose a method that can be called in any scope in a template.

Interface that is implemented by any classes that want to expose a method that can be called in any scope in a template that returns values dependent on the state of the iterator of the current scope.

This interface needs to be implemented by any template parser that is used in SSViewer

Contains references to any number of themes or theme directories

A class which builds a manifest of all themes (which is really just a directory called "templates")

Handles finding templates from a stack of template manifest objects.

A ViewableData object is any object that can be rendered into a template/view.

Allows you to render debug information about a {@link ViewableData} object into a template.

Contains logic which is shared between both WebAuthn's RegisterHandler and VerifyHandler, such as the attestation configuration options.

Implements the required interface from the WebAuthn library - but it does not implement the repository pattern in the usual way. This is expected to be stored on a DataObject for persistence. Use the

Exception to be thrown when a {see AuthenticatorAttestationResponse} is expected to contain attested credential data but does not. {see AuthenticatorData::hasAttestedCredentialData}

Represents an error found when the AuthenticatorResponse from a challenge is not of the expected type e.g. for verification we expect {see AuthenticatorAssertionResponse} but could instead be returned a {see AuthenticatorAttestationResponse} It is an extreme edge case, but is technically possible {see PublicKeyCredentialLoader::createResponse}

Locale metadata

Locales data source

Data sources for localisation strings. I.e. yml files stored within the /lang folder in any installed module.

Provides localisation of messages

Message reader. Inverse of Writer

Some arbitrary resource which expires when flush is invoked.

Loads yaml localisations across all modules simultaneously.

Implement message localisation using a symfony/translate backend

Allows serialization of entity definitions collected through {@link i18nTextCollector} into a persistent format, usually on the filesystem.

Write yml files compatible with ModuleYamlLoader

Parser that scans through a template and extracts the parameters to the _t and <%t calls

SilverStripe-variant of the "gettext" tool: Parses the string content of all PHP-files and SilverStripe templates for occurrences of the _t() translation method. Also uses the {@link i18nEntityProvider} interface to get dynamically defined entities by executing the {@link provideI18nEntities()} method on all implementors of this interface.

Base-class for storage and retrieval of translated entities.

Dynamically provide translatable entities for the {@link i18n} logic.

A workflow action that allows additional users or groups to be assigned to the workflow part-way through the workflow path.


A workflow action that notifies users attached to the workflow path that they have a task awaiting them.

Publishes an item

A simple approval step that waits for any assigned user to trigger one of the relevant transitions

Unpublishes an item

Allows workflow definitions to be exported from one SilverStripe install, ready for import into another.

Workflow definition import-specific logic.

Handles actions triggered from external sources, eg emails or web frontend

Provides a front end Form view of the defined Workflow Actions and Transitions

This DataObject replaces the SilverStripe cache as the repository for imported WorkflowDefinitions.

A workflow action describes a the 'state' a workflow can be in, and the action(s) that occur while in that state. An action can then have subsequent transitions out of the current state.

A workflow action attached to a {@link WorkflowInstance} that has been run, and is either currently running, or has finished.

An overall definition of a workflow

A WorkflowInstance is created whenever a user 'starts' a workflow.

A workflow transition.

Utility class to facilitate a simple YML-import via the standard CMS ImportForm() logic.

Handles interactions triggered by users in the backend of the CMS. Replicate this type of functionality wherever you need UI interaction with workflow.

WorkflowApplicable extension specifically for File objects, which don't have the same CMS UI structure so need to be handled a little differently. Additionally, it doesn't really work without custom code to handle the triggering of workflow, and in general is not ready for production use just yet.

DataObjects that have the WorkflowApplicable extension can have a workflow definition applied to them. At some point, the workflow definition is then triggered.

Adds embargo period and expiry dates to content items

A form field that allows workflow actions and transitions to be edited, while showing a visual overview of the flow.

Handles requests for creating or editing actions.

Handles individual record data editing or deleting.

Handles requests for creating or editing transitions.

Extends RequiredFields so we can prevent DO writes in AW's controller(s) without needing to catch Exceptions from DO->validate() all over the place.

This class is a {@link GridField} component that adds an export action for WorkflowDefinition objects shown in GridFields.

A queued job that publishes a target after a delay.

A central point for interacting with workflows

A task that sends a reminder email to users assigned to a workflow that has not been actioned for n days.

A class that wraps around an array description of a workflow

A modal search dialog which uses search context to search for and add existing records to a grid field.

Used by {@link GridFieldAddExistingSearchButton} to provide the searching functionality.

Builds on the {@link GridFieldEditableColumns} component to allow creating new records.

A component which lets the user select from a list of classes to create a new record form.

A custom grid field request handler that allows interacting with form fields when adding records.

GridFieldConfigurablePaginator paginates the {@link GridField} list and adds controls to the bottom of the {@link GridField}. The page sizes are configurable.

Allows inline editing of grid field records without having to load a separate edit interface.

Utility functions for the grid fields extension module.

Displays a link to an external source referenced 'external link'

Allows grid field rows to be re-ordered via drag and drop. Both normal data lists and many many lists can be ordered.

A base utility class for request handlers which present a grid field detail view.

A simple header which displays column titles.

A field that lets you specify both a key AND a value for each row entry

A checkboxset that uses a multivalue field for key / val pairs

A multivalued field that uses dropdown boxes for selecting the value for each

A multivalued field that uses a multi choice select box for selecting the value

A text field for multivalued text entry

A DB field that serialises an array before writing it to the db, and returning the array back to the end user.

Class QueuedTaskRunner

A QueuedJobDescriptor is the stored representation of a piece of work that could take a while to execute, because of which it is desirable to not have it executing in parallel to other jobs.

Class MaintenanceLockExtension Adds a maintenance lock UI to SiteConfig

An extension that can be added to objects that automatically adds scheduled execution capabilities to data objects.

Interface UserContextInterface used for jobs which need to specify which member to log in when running the jobs

An queued job to clean out the QueuedJobDescriptor Table which often gets too full

A job used to delete a data object. Typically used for deletes that need to happen on a schedule, or where the delete may have some onflow affect that takes a while to finish the deletion.

A job for generating a site's google sitemap

An example queued job

A convenience wrapper for running BuildTask implementations.

A job that gets executed on a particular schedule. When it runs, it will call the onScheduledExecution method on the owning dataobject.

A set of utility functions used by the queued jobs module

A base implementation of a queued job that provides some convenience for implementations

Default method for handling items run via the cron

Class EmailService

execute jobs immediately in the current request context

Class used to handle errors for a single job

Class ProcessManager

Interface definition for a queued job

Writes log output to a job descriptor

A service that can be used for starting, stopping and listing queued jobs.

A task that can be used to create a queued job.

An administrative task to delete all queued jobs records from the database.

Class BaseRunner

Runs all jobs through the doorman engine

Runs all jobs in a queue loop in one process

Runs tasks on a queue

Task used to process the job queue

An example build task that publishes a bunch of pages - this demonstrates a realworld example of how the queued jobs project can be used

Custom handling of save & publish actions this is needed to ensure correct localised version records are created Currently, the default save / publish actions call see Versioned::writeWithoutVersion() which breaks the Fluent functionality This extension injects the code which ensures the correct localisation is executed before the default action

Adds locale-specific extensions to ChangeSet

Fluent extension for {@link \SilverStripe\Control\Director} to apply routing rules for locales

Basic fluent extension

Supports GridFieldDetailForm_ItemRequest with extra actions

Represents an object that can only exist in a single locale

Available since SilverStripe 4.3.x

Fluent extension for SiteTree

Extension for versioned localised objects

Decorates admin areas for localised items with extra actions.

Shared functionality between both FluentExtension and FluentFilteredExtension

Base action for acting on a single locale / record pair

This class is a {@link GridField} component that adds a delete from locale action for objects.

Provides the "delete this locale" action

Menu grouped by item group

Provides the "publish this locale" action

Provides the "Save in this locale" action

Provides the "publish this locale" action

Adds a "visible in locales" column to a gridfield

DetectLocaleMiddleware will detect if a locale has been requested (or is default) and is not the current locale, and will redirect the user to that locale if needed.

InitStateMiddleware initialises the FluentState object and sets the current request locale and domain to it

This middleware will safely redirect you to the cms landing page when switching locales, in case you were viewing a url that does not apply to the new locale.

Allows you to cache a full list of objects without multiple DB queries

Archives a record, not just deletes

A policy that deletes the filtered rows.

A policy that deletes all localisations for a record

Generate a delete policy for a class

A policy that deletes the root record

Class FallbackLocale

Stores dates in the same timezone as DBDateTime, but will format them based on the timezone of another locale.

Object that represents details of a specific dataobject in a specific locale

Simple extension to enable SS Core search to work with SS Fluent

Allow FulltextSearch to index content from all configured locales, and support users searching to be restricted to their active locale. Works in a very similar way to SearchVariantVersioned from the FulltextSearch module (where that variant restricts searches to live pages, etc.)

Copy content between locales

Detects locale based on browser locale

Detects locale based on cloudflare geo-location headers

Stores the current fluent state

Provides migration from the Translatable module in a SilverStripe 3 website to the Fluent format for SilverStripe 4.