An AfterCallAspect is run after a method is executed

Aggregate deprecated

Calculate an Aggregate on a particular field of a particular DataObject type (possibly with an additional filter before the aggregate)

A subclass of Aggregate that calculates aggregates for the result of a has_many query.

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

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

Library of static methods for manipulating arrays.

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

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

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

Abstract base class for an authentication method

BBCode parser object.

Provides an interface to HTTP basic authentication.

A BeforeCallAspect is run before a method is executed.

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.

Content side-report listing pages with broken links

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).

A class representing back actions.

Special request handler for admin/batchaction

Archives a page, removing it from both live and stage

Delete items batch action.

Unpublish (delete from live site) items batch action.

Publish items batch action.

Batch restore of pages

Unpublish items batch action.

Deals with special form handling in CMS, mainly around {@link PjaxResponseNegotiator}

The main "content" area of the CMS.

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

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

A simple CMS menu item.

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.

Provides a security interface functionality within 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".

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

Class to handle parsing of CSV files, where the column headers are in the first row.

A decorator for a Zend_Cache_Backend cache service that mutates cache keys dynamically depending on versioned state

Standard Change Password Form

Single checkbox field.

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

Displays a set of checkboxes as a logical group.

Provides introspection information about the class tree.

Wipe the cache of failed image manipulations. When {@link GDBackend} attempts to resample an image, it will write the attempted manipulation to the cache and remove it from the cache if the resample is successful. The objective of the cache is to prevent fatal errors (for example from exceeded memory limits) from occurring more than once.

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

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

Test reporter optimised for CLI (ie, plain-text) output

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

Apply this interface to any {@link DBField} that doesn't have a 1-1 mapping with a database field.

Base class for all fields that contain other fields.

The configuration system works like this:

Config_LRU deprecated

Two masked input fields, checks for matching passwords.

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

Extension to provide a search interface when applied to ContentController

The content negotiator performs "text/html" or "application/xhtml+xml" switching.

Base controller class.

Library of conversion functions, implemented as static methods.

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.

A simple extension to dropdown field, pre-configured to list countries.

Allows input of credit card numbers via four separate form fields, including generic validation of its numeric values.

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

Represents a decimal field containing a currency amount.

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

Readonly version of a {@link CurrencyField}.

Readonly version of a {@link CurrencyField}.

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


Global database interface, complete with static methods.

Represents an object responsible for wrapping DB connector api

Single field in the database.

Represents a floating point field.

Represents a signed 32 bit integer field.

Locale database field, mainly used in {@link Translatable} extension.

Builds a SQL query string from a SQLExpression object

Represents and handles all schema management for a database

DailyTask deprecated

Classes that must be run daily extend this class.

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

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

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.

Implements a "lazy loading" DataObjectSet.

Representation of a DataModel - a collection of DataLists for each different data type.

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.

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

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

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

DatabaseAdmin class

Interface for database helper classes.

Abstract class for all fields without data.

Represents a date field.

Form field to display an editable date string, either in a single <input type="text"> field, or in three separate fields for day, month and year.

Disabled version of {@link DateField}.

Preliminary API to separate optional view properties like calendar popups from the actual datefield logic.

A composite field for date and time entry, based on {@link DateField} and {@link TimeField}.

The readonly class for our {@link DatetimeField}.

Supports debugging and core error handling.

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

Represents a Decimal field.

Handles raising an notice when accessing a deprecated method

Base class for development tools.

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

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

Transformation that disables all the fields on the form.

Dropdown field, created from a select tag.

Class to support sending emails.

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

Encrypt all passwords

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

Class Enum represents an enumeration of a set of strings.

Class ErrorControlChain

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

Enhances error handling for a controller with ErrorPage generated output

Controller for ErrorPages.

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

Checks if a value is in a given set.

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

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

A list designed to hold form field instances.

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

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

Filter certain characters from file name, for nicer (more SEO-friendly) URLs as well as better filesystem compatibility. Can be used for files and folders.

A collection of static methods for manipulating the filesystem.

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.

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

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

Represents a folder in the assets/ directory.

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

Base class for all forms.

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

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

Represents a field in a form.

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

Note that this will cause duplicate and invalid ID attributes.

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

Filters by full-text matching on the given field.

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

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 is maintained for backwards-compatibility only. Please use the {@link GDBackend} class instead.

A wrapper class for GD-based images, with lots of manipulation functions.

Selects numerical/date content greater than the input

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

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 "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.

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.

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.

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.

A security group.

Imports {@link Group} records by CSV upload, as defined in {@link GroupCsvBulkLoader}.

Grouped dropdown, using optgroup tags.

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

Base class for HTML cleaning implementations.

Represents a large text field that contains HTML content.

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

A class with HTTP-related helpers.

Class HTTPCacheControl

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

Field that generates a heading tag.

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.

Hidden field.

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.

HourlyTask deprecated

Classes that must be run hourly extend this class

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.

Encapsulation of an oembed tag, linking to an external media source.

Encapsulation of a file which can either be a remote URL or a {@link File} on the local filesystem, exhibiting common properties such as file name or the URL.

Encapsulation of an image tag, linking to an image either internal or external to the site.

Readonly version of an {@link HTMLEditorField}.

Toolbar shared by all instances of {@link HTMLEditorField}, to avoid too much markup duplication.

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

Interface, implementing the general PHPUnit wrapper API.

Represents an Image


A resized / processed {@link Image} object.

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.

Render a button that will submit the form its contained in through ajax.

Readonly version of {@link InlineFormAction}.

Simple controller that the installer uses to test that URL rewriting is working.


Controller that executes QUnit tests via jQuery.

Simple label, to add extra text in your forms.

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

Plug-ins for additional functionality in your LeftAndMain classes.

Extension to include custom page icons

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

Wrapper around objects being displayed in a tree.

Selects numerical/date content less than the input

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

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

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

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

Abstract base class for a login form

Read-only complement of {@link DropdownField}.

Mailer objects are responsible for actually sending emails.

A basic caching interface that manifests use to store data.

Stores manifest data in APC.

Stores manifest data in files in TEMP_DIR dir on filesystem

Same as ManifestCache_File, but stores the data as valid PHP which gets included to load This is a bit faster if you have an opcode cache installed, but slower otherwise

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

  • Only modules with _config.php files are scanned.

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

Computes diff between sequences of strings.

The member class which represents the users of the system

Authenticator for the default "member" method

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

Imports {@link Member} records by CSV upload, as defined in {@link MemberCsvBulkLoader}.

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

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

Class used as template to send an email saying that the password has been changed.

Class used as template to send the forgot password email

Represents a set of Groups attached to a member.

Member Validator

Rewrites plain internal HTML links into shortcode form, using existing link tracking information.

A migration task is a build task that is reversible.

Generates a three-pane UI for editing model classes, with an automatically generated search panel, tabular results and edit forms.

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

Implements the "Money" pattern.

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

MonthlyTask deprecated

Classes that must be run monthly extend this class

Represents an multi-select enumeration field.

MySQL connector class.

This is a helper class for the SS installer.

A result-set from a MySQL database (using MySQLiConnector)

Builds a SQL query string from a SQLExpression object

Represents schema management object for MySQL

Provides a record-view for mysqli statements

Connector for MySQL using the MySQLi method

NegationFilter deprecated

Matches on rows where the field is not equal to the given value.

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

This is a form decorator that lets you place a form inside another form.

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

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

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.

Readonly version of a numeric field.

Format of the Oembed config. Autodiscover allows discovery of all URLs.

Set of radio buttons designed to emulate a dropdown.

PDO driver database connector

A result-set from a PDO database.

PHPUnit is a testing framework that can be installed using Composer.

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

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

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.

Password input field.

This class represents a validator for member passwords.

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

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.

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

Field for displaying phone numbers. It separates the number, the area code and optionally the country code and extension.

PHPUnit Wrapper class.

PHPUnit Wrapper class. Implements the correct behaviour for PHPUnit V3.4.

PHPUnitWrapper Exception class

Generic PhpUnitWrapper.

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.

A special ForeignKey class that handles relations with arbitrary class types

Represents a has_many list linked against a polymorphic relationship

A special type Int field used for primary keys.

Transformation that will make a form printable.

Class representing printable tabsets

Profiler deprecated

Execution time profiler.

Cleans HTML using the HTMLPurifier package

QuarterHourlyTask deprecated

Classes that must be run quarter hourly extend this class

RSSFeed class

RSSFeed_Entry class

Generates entropy values based on strongest available methods (mcrypt_create_iv(), openssl_random_pseudo_bytes(), /dev/urandom, COM.CAPICOM.Utilities.1, mt_rand()).

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

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

A redirector page redirects when the page is visited.

Controller for the {@link RedirectorPage}.

Regenerate all cached images that have been created as the result of a manipulation method being called on a {@link Image} object

A DataList that represents a relation.

Identify "orphaned" pages which point to a parent that no longer exists in a specific stage.

Reports section of the CMS.

A request filter is an object that's executed before and after a request occurs. By returning 'false' from the preRequest method, request execution will be stopped from continuing

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

Represents a request processer that delegates pre and post request handling to nested request filters

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.

Requirements tracker for JavaScript and CSS.

Action that clears all fields on a form.

RestfulService class allows you to consume various RESTful APIs.

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.

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

Object representing a SQL INSERT query.

SQLQuery deprecated

Object representing a SQL SELECT query.

Provides conversion of parameterised SQL to flattened SQL strings

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)

Dummy class that filters need to extend from.

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)

The [api:SS_Cache] class provides a bunch of static functions wrapping the Zend_Cache system in something a little more easy to use with the SilverStripe config system.

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 some additional items present in a directory, and caches it.

Class to facilitate command-line output.

A utility class which builds a manifest of configuration items

A utility class which builds a manifest of the statics defined in all classes, along with their access levels and values

A parser that processes a PHP file, using PHP's built in parser to get a string of tokens, then processing them to find the static class variables, their access levels & values

Allows access to config values set on classes using private statics.

A Directed Acyclic Graph - used for doing topological sorts on dependencies, such as the before/after conditions in config yaml fragments

Exception thrown when the {@link SS_DAG} class is unable to resolve sorting the DAG due to cyclic dependencies.

Abstract database connectivity class.

Error class for database exceptions

Represents a date-time field.

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

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

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

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 SS_HTTPResponse} encapsulated in an exception, which can interrupt the processing flow and be caught by the {@link RequestHandler} and returned to the user.

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

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

A base class for decorators that wrap around a list to provide additional functionality. It passes through list methods to the underlying list implementation.

Wrapper class for a logging handler like {@link Zend_Log} which takes a message (or a map of context variables) and sends it to one or more {@link Zend_Log_Writer_Abstract} subclasses for output.

Sends an error message to an email.

Formats SS error emails with a basic layout.

Formats SS error entries in an error file log.

Writes an error message to a file.

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

Builds a map iterator around an Iterator. Called by SS_Map

A base class for all SilverStripe objects to inherit from.

Abstract query-result class.

Base "abstract" class creating reports on your data.

SS_ReportWrapper is a base class for creating report wappers.

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

Sends an error message to the system log whenever an error occurs.

Handles finding templates from a stack of template manifest objects.

A class which builds a manifest of all templates present in a directory, in both modules and themes.

Necessary to call setUpOnce() and tearDownOnce() on {@link SapphireTest} classes. This feature doesn't exist in PHPUnit in the same way (setUpBeforeClass() and tearDownAfterClass() are just called statically).

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

Extensions to Zend_Log to make it work nicer with {@link SS_Log}.

Returns information about the current site instance.

Test case class for the Sapphire framework.

Gathers details about PHPUnit2 test suites as they are been executed. This does not actually format any output but simply gathers extended information about the overall results of all suites & their tests for use elsewhere.

Light wrapper around {@link PHPUnit_Framework_TestSuite} which allows to have {@link setUp()} and {@link tearDown()} methods which are called just once per suite, not once per test method in each suite/case.

ScheduledTask deprecated

Abstract task representing scheudled tasks.

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

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

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

Implements a basic security model

Security section of the CMS

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

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}.

Used to locate configuration for a particular named service.

Handles all manipulation of the session.

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

Renderer for showing SideReports in CMSMain

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

Inject SilverStripe 'setUpOnce' and 'tearDownOnce' unittest extension methods into PHPUnit.

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

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

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

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()}

Http utility functions.

A factory which is used for creating service instances.

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.

Base interface for any {@link DataObject} passed back as a node.

Class IntrospectionProvider

Base type for query types within graphql. I.e. mutations or queries

Base type creator for interface type generation.

Manager is the master container for a graphql endpoint, and contains all queries, mutations, and types.

Represents middleware for evaluating a graphql query

Represents a writable entrypoint field in the top level graphql 'mutation' schema

Standard resolve callback for Mutations or Queries

A connection to a list of items on a object type. Collections are paginated and return a list of edges.

Supports offset based pagination within GraphQL.

A helper class for making a paginated query. A paginated query uses the {@link Connection} object type to encapsulate the edges, nodes and page information.

Type for specifying the sort direction for a specific field.

Type creator for an enum value for a list of possible sortable fields

Defines a service that can filter a list with a permission check against a member

Class FileProvider

Class HTTPProvider

Class ConfigStringProvider

Interface PersistedQueryMappingProvider

Represents a queryable entrypoint field in the top level graphql 'query' schema

Defines the interface used by all read filters for scaffolded operations

A special type of filter that accepts list values

Adds functionality to associate an object with a given GraphQL type, either internal (e.g. String) or complex (e.g. object)

Defines the methods required for a class to accept a configuration as an array

Defines a class that updates the Manager

ResolverInterface deprecated

Applied to classes that resolve queries or mutations

Defines a class that transforms into a type or field creator

Use on classes that update the GraphQL scaffolder

Defines the interface used for services that create GraphQL types based on simple input, e.g. a formatted string or array

A generic "create" operation for a DataObject.

A generic delete operation.

Scaffolds a generic read operation for DataObjects.

Scaffolds a generic read operation for DataObjects.

Scaffolds a generic update operation for DataObjects.

Scaffolds a DataObjectTypeCreator.

Scaffolds a UnionType based on the ancestry of a DataObject class

Scaffolds a GraphQL query field.

Scaffolds a GraphQL query field.

Scaffolds a GraphQL mutation field.

Provides functionality common to both operation scaffolders. Cannot be a subclass due to their distinct inheritance chains.

Scaffolds a GraphQL query field.

The entry point for a GraphQL scaffolding definition. Holds DataObject type definitions, and their nested Mutation/Query definitions.

Global map of dataobject classes to graphql schema types.

Offers a few helper methods for classes that are DataObject subclass bound.

Parses a map of type, e.g. Int!(20) into an array defining the arg type

An array list designed to work with OperationScaffolders

Parses a type, e.g. Int!(20) into an array defining the arg type

Represents a GraphQL type in a way that allows customization through SilverStripe's {@link DataExtension} system.

Infer original field name casing from case insensitive field comparison.


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.

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

A helper object for extracting information about links.

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

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

Checks if a value starts with one of the items of in a given set.

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


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

Defines a set of tabs in a form.

This is a form decorator (a class that wraps around a form) providing us with some functions to display it in a Tabular style.

Bind TeamCity test listener. Echos messages to stdout that TeamCity interprets into the test results

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 dependant 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

Classes that implement TestOnly are only to be used during testing

Controller that executes PHPUnit tests.

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

Wrapper around SS_HTTPResponse to make it look like a SimpleHTTPResposne

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

Text input field.

Parses text in a variety of ways.

TextareaField creates a multi-line text field, allowing more data to be entered than a standard text field. It creates the