SAIF.Framework.Core API reference

This page lists all public types exposed by SAIF.Framework.Core, grouped implicitly by namespace. Each type links to its full API reference page. Types marked internal in their own page are included here because they are documented as part of this library's traced operations, but are not accessible outside the assembly.

Types

Type	Kind	Namespace	Purpose
Address	Class	SAIF.Core.Contracts	Address is a serializable data-transfer object that models a postal address, including domestic ZIP+4 formatting and foreign-address handling, and provides formatting helpers used to render an address as a single string or as a list of display lines.
AddressType	Class	SAIF.Core.Contracts	AddressType is a CodeTableItem specialization used to classify an Address instance (via Address.AddressType) with a code/description pair, such as distinguishing mailing addresses from physical addresses*. It adds no members beyond its base type.
ApplicationExceptionDetail	Class	SAIF.Core.Contracts	ApplicationExceptionDetail is a data-transfer object that captures the context around an application exception — which application, environment, machine, user, and page it occurred on, along with the exception's message, source, and the raw Exception object — for use in error reporting/logging scenarios*.
ApplicationTrackSettings	Class	SAIF.Core.Contracts.Core	ApplicationTrackSettings is a data-transfer object that carries the plain string-keyed/string-valued configuration settings for a given application track and environment, as a lighter-weight alternative to ConfigurationSettings (which uses typed ConfigSetting values)*.
BusinessOnlineMenu	Class	SAIF.Core.Contracts.Menu	BusinessOnlineMenu is a data-transfer object that models the navigation menu for a Business Online-style application for a given user, splitting entries into a favorites list and the full set of available menu items, as returned by IMenuService.GetBusinessOnlineMenu.
BusinessOnlineMenuItem	Class	SAIF.Core.Contracts.Menu	BusinessOnlineMenuItem is a data-transfer object representing a single navigable entry within a BusinessOnlineMenu — the target application/page, its category grouping, a display tooltip, and an optional favorite name when the item appears in a user's favorites list.
Category	Class	SAIF.Core.Contracts.Imaging	Category is a CodeTableItem specialization representing an imaging document category, which groups a collection of DocumentType values that belong to it.
CodeTableItem	Class	SAIF.Core.Contracts	CodeTableItem is the common serializable base type for code/description pairs used throughout the framework's contract types (for example AddressType, PhoneType, CountryCode, StateCode, imaging Category, and DocumentType), giving every reference-data lookup value a consistent Code/Description shape.
Company	Class	SAIF.Core.Contracts	Company is a data-transfer object representing a business entity, holding its identifier, name, tax ID, and a collection of associated Address records.
ConfigSettingRequest	Class	SAIF.Core.Contracts.Core	ConfigSettingRequest is a data-transfer object that packages a set of ConfigSetting values along with metadata about who requested the change/read (ApplicationId, RequestedBy, RequestedOn), used to send configuration-setting operations to an environment/configuration service*. Its identifying fields are immutable readonly instance fields rather than properties.
ConfigurationSettings	Class	SAIF.Core.Contracts.Core	ConfigurationSettings is a data-transfer object that represents the full set of configuration key/value settings for an application track, along with bookkeeping timestamps for when the settings were refreshed from their source and last loaded, so environment-configuration consumers can tell whether a cached copy is stale.
CountryCode	Class	SAIF.Core.Contracts.Core	CountryCode is a CodeTableItem specialization representing a country reference-data value, and exposes the constant UnitedStatesCode ("US") used by its companion CountryCodeExtensions static class to identify the United States within a collection of country codes.
DocumentType	Class	SAIF.Core.Contracts.Imaging	DocumentType is a CodeTableItem specialization representing an imaging document type — the specific kind of document within a Category — along with display and confidentiality metadata used when presenting or handling imaged documents.
FaxInfoClass	Class	SAIF.Core.Contracts.Documents	FaxInfoClass is a data-transfer object that carries the information needed to send a fax — the attachment to send, a cover-sheet note, and the recipient's name, company, fax number, and voice number — for use by a fax-sending service*.
Group	Class	SAIF.Core.Contracts.Security	Group is a data-transfer object representing a directory (e.g. Active Directory) security or distribution group, carrying its name, identifiers (GUID/SID), scope, distinguished name, and a flag distinguishing security groups from other group types; it is used as the element type of UserProfile.Groups.
ImageBase	Class	SAIF.Core.Contracts.Imaging	ImageBase is an abstract base class for imaged-document records, carrying the common attributes every image shares — identity, document date, extracted/associated text, soft-delete state, its Category/DocumentType classification, and audit (create/update) metadata — so concrete imaging document types can share a single set of fields instead of redefining them.
IMenuService	Interface	SAIF.Core.Contracts.Menu	IMenuService is the contract for retrieving a user's BusinessOnlineMenu, keyed by a mail identifier, allowing consuming applications to depend on the abstraction rather than a concrete menu-retrieval implementation.
IWebContext	Interface	SAIF.Core.Contracts.WebContext	IWebContext is the contract for a per-request/session web context that carries a fixed set of well-known claim/policy identifiers (ClaimId, ClaimNumber, PolicyNumber, ProviderNumber, CurrentValue) alongside an extensible key/value store (Get/Set/GetAll) for arbitrary contextual data, identified by ContextId; implementations are produced and persisted via IWebContextService.
IWebContextService	Interface	SAIF.Core.Contracts.WebContext	IWebContextService is the contract for retrieving and persisting IWebContext instances, supporting lookup by a combination of application name and session ID, by a context ID directly, or with no arguments to obtain a default/ambient context.
PDFTracking	Class	SAIF.Core.Contracts.PDF	PDFTracking is a data-transfer object that tracks the status and location of a PDF conversion/generation job, identifying the source system that requested it, the resulting output file, and whether the output conforms to the PDF/A archival format.
Person	Class	SAIF.Core.Contracts	Person is a serializable data-transfer object that models a single individual's demographic and identity attributes (name parts, gender/ethnicity codes, driver's license, and tax identifiers), and exposes a Name() method that concatenates first, middle, and last name into a single display string.
PersonName	Class	SAIF.Core.Contracts	PersonName is a serializable data-transfer object holding the individual parts of a person's name (title, first, middle, last, suffix, preferred), separate from the PersonNameExtensions static class in the same file, which supplies multiple formatting strategies (full name with title, employee-list format, standard first/last order, and a short first/last form) for rendering a PersonName as display text.
PhoneNumber	Class	SAIF.Core.Contracts	PhoneNumber is a serializable data-transfer object that both stores the structural parts of a phone number (country code, long-distance indicator, area code, prefix, number, extension) and knows how to parse a raw digit string into those parts (SetValue/internal deFormat) and re-render them as a formatted display string.
PhoneType	Class	SAIF.Core.Contracts	PhoneType is a serializable CodeTableItem specialization used to classify a PhoneNumber instance (via PhoneNumber.PhoneType) with a code/description pair, such as distinguishing home, work, or mobile numbers*. It adds no members beyond its base type.
Section	Class	SAIF.Core.Contracts.Core.Configurations	Section is a data-transfer object that summarizes a configuration section within a track — its name, how many keys it contains, and when it was last updated — used to present or manage groups of related configuration settings.
StateCode	Class	SAIF.Core.Contracts.Core	StateCode is a CodeTableItem specialization representing a U.S. state (or equivalent jurisdiction) reference-data value, and exposes the constant OregonCode ("OR") used by its companion StateCodeExtensions static class to identify Oregon within a collection of state codes.
Track	Class	SAIF.Core.Contracts.EnvironmentApi	Track is a data-transfer object representing an application deployment track (e.g. an environment track such as dev1 or prod) and the set of hostnames that belong to it, used by environment-resolution logic to determine which track a running host belongs to*.
UC4Environment	Class	SAIF.Core.Contracts.UC4	UC4Environment is an enumeration of the UC4 job-scheduling client environments (development, entdev, test, enttest, SIT/UAT/QA variants, and production), each mapped to a numeric UC4 client ID; it is consumed by the companion UC4EnvironmentFactory class to translate an application track or numeric client ID into the matching environment.
UC4Result	Class	SAIF.Core.Contracts.UC4	UC4Result is a data-transfer object representing the outcome of invoking a UC4 job/process, carrying the run identity, success/failure state, any error or access-denied information, and the parameters passed to the job.
UserProfile	Class	SAIF.Core.Contracts.Security	UserProfile is a data-transfer object representing an authenticated user's directory profile — identity, name, contact, account-status, and login-history attributes — along with the Group memberships (Groups) the user belongs to, as returned by directory/security lookup services.
WebContextItem	Class	SAIF.Core.Contracts.WebContext	WebContextItem is a serializable data-transfer object representing a single persisted key/value entry of a web context — the underlying storage unit behind an IWebContext's general-purpose key/value store, scoped to an application name and session*.
ApplicationEnvironment	Enum	SAIF.Core	ApplicationEnvironment identifies the deployment tier that a SAIF application is currently running in.* It is returned by IEnvironmentService.GetApplicationEnvironment(), letting callers branch configuration or behavior based on whether code is executing in a development, test, QA, production, or global context.*
NonWorkDayOption	Enum	SAIF.Core	NonWorkDayOption controls how IWorkCalendarService.NextWorkDay(DateTime, int, NonWorkDayOption, WorkCalendar) resolves a target date that falls on a non-working day.* It selects whether the calculation rolls forward to the next work day or back to the previous work day before applying the requested day offset.*
PaperTray	Enum	SAIF.Core	PaperTray identifies the physical printer tray a print job should draw paper from.* It is used on PrintConfig.PaperTray and defaults to Tray2 in PrintConfig.GetDefaultConfig, letting print requests select a numbered tray or the envelope feeder.*
PlexMode	Enum	SAIF.Core	PlexMode selects the duplexing behavior applied to a print job.* It is consumed by IPrintService.PrintPdf and PrintConfig.PlexMode to control whether a document prints on one side or both sides of the page, and defaults to Simplex in PrintConfig.GetDefaultConfig.*
ScaleMode	Enum	SAIF.Core	ScaleMode controls how a printed document's content is scaled relative to the printable area of the page.* It is consumed by IPrintService.PrintPdf and PrintConfig.ScaleMode, and defaults to None in PrintConfig.GetDefaultConfig, meaning documents print without automatic scaling unless a mode is explicitly selected.*
WorkCalendar	Enum	SAIF.Core	WorkCalendar identifies which named work-day calendar IWorkCalendarService should use when computing working-day dates.* It is passed as a default parameter to methods such as FirstWorkDayOfMonth, LastWorkDayOfMonth, NextWorkDay, PreviousWorkDay, and IsWorkingDay, and currently exposes only the Saif calendar.*
ADService	Class	SAIF.Core.Services	ADService is an internal class (declared internal, not accessible outside SAIF.Framework.Core) used exclusively by MachineSecurityService to resolve Active Directory group membership through a direct, in-process LDAP lookup, avoiding a network round trip to the WCF SecurityService. It performs a recursive group-membership walk with cycle protection to safely traverse nested AD groups.
Contact	Class	SAIF.Core.Services.UserProfile	Contact is a serializable data-transfer object carrying a user's personal and organizational contact details — address, phone/fax, name, email, gender, and employer information. It is exposed via IApplicationUserProfile.Contact. The same file also declares the supporting Company and Location types describing organizational placement.
ConversionResult	Class	SAIF.Core.Services.Documents.PDF	ConversionResult is the return type of IPdfService.Convert/ConvertTo, carrying zero or more output files (as FileResult entries) alongside a success/error status. Success is derived purely from ErrCode being zero, and the convenience File property returns the first output file's bytes only when the conversion succeeded.
DocumentGenerationConfig	Class	SAIF.Core.Services.Documents	DocumentGenerationConfig is the data-transfer object driving document generation across IDocumentService.GenerateDocument, IDocumentService.DistributeDocument, and IPrintService.PrintDocument: it identifies the document package to render, the XML data driving it, and the desired output document type.
IApplicationUserProfile	Interface	SAIF.Core.Services.UserProfile	IApplicationUserProfile extends ISystemUserProfile with account-state, domain, and contact/preference information for a user known to a specific application. It is the common base for the more specialized ISaifUserProfile (internal employees) and IExternalUserProfile (external users), and is the type returned by IUserProfileService.GetApplicationUser/GetCurrentUser.
IDocumentService	Interface	SAIF.Core.Services.Documents	IDocumentService is the top-level document-generation and distribution facade, aggregating email, imaging, printing, and fax collaborators behind a single contract. Consumers use it to discover available document packages, generate PDFs/documents from those packages, and distribute the generated output through one or more channels (email, print, fax, image archival) in a single call.
IEmailService	Interface	SAIF.Core.Services	IEmailService is the minimal outbound-email contract used by document distribution flows (IDocumentService.DistributeDocument) to send a fully constructed System.Net.Mail.MailMessage without exposing SMTP transport details to callers.
IEnvironmentService	Interface	SAIF.Core.Services	IEnvironmentService is the environment-abstraction contract consumed throughout SAIF.Framework.Core to answer "where am I running" questions (production vs. non-production, developer machine, web vs. non-web host, firewall/external client) and to read configuration, including secure configuration gated by a caller-supplied hash value. MachineSecurityService and SecurityGroupService depend on similar environment/configuration information for AD/LDAP connection settings resolved through configuration accessors.*
IExternalTestUserProfile	Interface	SAIF.Core.Services.UserProfile	IExternalTestUserProfile extends IExternalUserProfile with the additional state needed for external test accounts: whether the test account is permitted to access production, and an optional expiration date after which the test account should no longer be usable. It is returned by IUserProfileService.GetExternalTestUser.
IExternalUserProfile	Interface	SAIF.Core.Services.UserProfile	IExternalUserProfile extends IApplicationUserProfile with information specific to external (non-employee) users, including user-agreement acceptance state, a categorized ExternalUserType, and the last-login message shown to the user. It is returned by IUserProfileService.GetExternalUser, GetInjuredWorkerUserByCustomerId, and GetExternalUserByCustomerId.
IFaxService	Interface	SAIF.Core.Services.Documents	IFaxService sends a fax composed of a file payload and one or more recipients, described by the companion FaxConfig type. Fax requests are validated before sending: a FaxConfig must carry a non-empty file and at least one recipient, and each recipient must carry both a fax number and a name (BR-CORE-07 through BR-CORE-10).
IImagingService	Interface	SAIF.Core.Services.Documents	IImagingService is the archival/imaging channel contract used to store files in the imaging system, convert stored files to PDF, and resolve file locations/paths for previously imaged content. IDocumentService exposes it as the ImagingService collaborator used during document distribution.
ILogService	Interface	SAIF.Core.Services	ILogService is the core logging and exception-recording contract implemented by logging providers across SAIF.Framework.Core consumers. It combines structured exception logging with leveled trace methods (Debug/Info/Warn/Error) and a runtime-adjustable trace threshold, and is itself IDisposable so implementations can hold onto log-sink resources (file handles, network log clients).
ILogServiceForApi	Interface	SAIF.Core.Services	ILogServiceForApi extends ILogService for API-hosted consumers that need to correlate a logged exception with a caller-supplied request/correlation identifier (id), in addition to the base application/page/state context.
IMachineSecurityService	Interface	SAIF.Core.Services	IMachineSecurityService is an internal-visibility contract (declared without the public modifier, so it is only usable within SAIF.Framework.Core and assemblies granted InternalsVisibleTo access) that abstracts machine-account authorization checks against an AD group. Its sole implementation, MachineSecurityService, is used by EnvironmentServiceBase.IsDeveloperMachine to determine whether the current host is a member of a developer-machine authorization group.*
ImageConfig	Class	SAIF.Core.Services.Documents	ImageConfig is a data-transfer object carrying the metadata needed to file a document into the imaging system: claim/policy/agency identifiers, category/document-type/document-name codes, display fields, and creation/receipt dates. It is passed to IImagingService.QueueImage, IPdfService.ConvertAsync/MergeAsync, and IDocumentService.DistributeDocument.
IMessageContainer	Interface	SAIF.Core.Services	IMessageContainer is a collector contract for accumulating user-facing validation feedback at three severities (error, warning, information). It is exposed via IValidatingService.MessageContainer so validating services can report multiple issues from a single validation pass rather than throwing on the first failure.*
IPdfService	Interface	SAIF.Core.Services.Documents.PDF	IPdfService is the PDF conversion, merge, and inspection contract. It supports both synchronous, WCF-service-backed conversion/merge (Convert, ConvertTo, Merge, Extract) and an asynchronous, folder-drop-based path (ConvertAsync, MergeAsync) where files are placed for out-of-process processing by the PDF converter/merge services, with status tracked via pdf_tracking records and polled through CheckPdfTrackingStatus.
IPreferences	Interface	SAIF.Core.Services.UserProfile	IPreferences exposes a user's stored preferences from the perspective of that user's profile (as opposed to IPreferenceService, which is the service-level contract keyed explicitly by user ID). It is surfaced via IApplicationUserProfile.Preferences, and its DefaultPrinter value is used by PrintConfig.GetDefaultConfig.
IPreferenceService	Interface	SAIF.Core.Services	IPreferenceService persists and retrieves free-form key/value user preferences scoped by application, and optionally by page, within that application. It also exposes a dedicated accessor for a user's default printer, used by PrintConfig.GetDefaultConfig.*
IPrintService	Interface	SAIF.Core.Services	IPrintService abstracts sending print jobs either as a raw PDF-generation package (an XML-driven document package name plus an XML payload) or as a fully-generated document, routed to a physical printer with duplex/scale/copy settings. IDocumentService exposes it as the PrintService collaborator used by document distribution.
ISaifUserProfile	Interface	SAIF.Core.Services.UserProfile	ISaifUserProfile extends IApplicationUserProfile with employment-specific information for internal SAIF employees: employee ID, job title, department, and manager identification. It is returned by IUserProfileService.GetSaifUser/GetSaifEmployee.
ISecurityApiClient	Interface	SAIF.Core.Services	ISecurityApiClient is the REST-based client contract for the Security API, used to resolve user profile information and to check role-based authorization. Unlike ISecurityGroupService (which calls the legacy WCF SecurityService), this client targets the newer REST Security API and enforces domain\username format validation before any network call is made (BR-CORE-05, BR-CORE-12).
ISecurityGroupService	Interface	SAIF.Core.Services	ISecurityGroupService resolves AD group membership through the legacy WCF SecurityService, either by an exact group name or by an authorization "resource" name that is normalized to an environment-scoped group name before the call (BR-CORE-01). See SecurityGroupService.GetMembersByResource operation for the detailed member-resolution flow.
IService	Interface	SAIF.Core.Services	IService is an intentionally empty marker interface used to tag types as services within SAIF.Framework.Core for classification/discovery purposes (e.g., service registration or type-scanning). The same source file also declares IValidatingService, a service that additionally exposes an IMessageContainer for collecting validation feedback.*
ISystemUserProfile	Interface	SAIF.Core.Services.UserProfile	ISystemUserProfile is the minimal user-identity contract: a user identifier plus role-based authorization and demo-user classification. It is the base interface for IApplicationUserProfile and is returned directly by IUserProfileService.GetSystemUser for callers that only need identity and authorization, not full profile/contact data.
IUC4Service	Interface	SAIF.Core.Services	IUC4Service abstracts triggering jobs on the UC4 (Automic) job-scheduling/automation platform, either with no parameters or with a named parameter dictionary, always accompanied by ClientInfo describing the calling client.
IUserProfileService	Interface	SAIF.Core.Services.UserProfile	IUserProfileService is the factory/lookup contract for resolving user profile objects at different levels of specificity — generic system user, application user, internal SAIF employee, and external (including test) users — plus a shortcut for resolving the currently authenticated caller's application profile.
IValidationService	Interface	SAIF.Core.Services	IValidationService is the generic entity-validation contract implemented by FluentValidationService, wrapping FluentValidation-style rule execution behind a simple Validate/ValidateAndThrow surface. Notably, the single-argument Validate<T>(T) overload has a documented side effect: it also runs the "AuthorizationRules" rule set on the same entity (BR-CORE-11).
IWorkCalendarService	Interface	SAIF.Core.Services	IWorkCalendarService provides business-day (work-day) calendar calculations against a selectable WorkCalendar, used by consumers that need to schedule or validate dates against organizational holidays/weekends rather than raw calendar dates.
MachineSecurityService	Class	SAIF.Core.Services	MachineSecurityService implements IMachineSecurityService, checking whether a machine account is a member of an AD authorization group by delegating to the internal ADService for a direct, in-process LDAP lookup rather than calling the WCF SecurityService. It is used by EnvironmentServiceBase.IsDeveloperMachine to determine whether the current host belongs to the developer_machine_users group.
MergeDefinition	Class	SAIF.Core.Services.Documents.PDF	MergeDefinition describes one input file (and which page ranges from it) to include when IPdfService.Merge/Extract produce a combined output PDF. It is a [DataContract] type so it can cross the WCF PDF service boundary, and offers three constructors covering explicit page ranges, a simple start/end page range, and "merge the whole file."
PdfTrackingResult	Class	SAIF.Core.Services.Documents.PDF	PdfTrackingResult is the immutable result returned by IPdfService.ConvertAsync/MergeAsync, carrying the identifiers needed to later look up a PDF and/or image once the asynchronous conversion/merge job has been scheduled.
PdfTrackingStatus	Class	SAIF.Core.Services.Documents.PDF	PdfTrackingStatus is an enumeration mirroring the values found in the pdf_cache_status_code reference data, returned by IPdfService.CheckPdfTrackingStatus to report the current state of an asynchronously scheduled PDF conversion or merge job.
PrintConfig	Class	SAIF.Core.Services.Documents	PrintConfig is a data-transfer object carrying physical print settings (copies, printer name, duplex mode, scale mode, paper tray) for IPrintService.PrintDocument and IDocumentService.DistributeDocument. Its static GetDefaultConfig factory builds a default configuration seeded from a user's stored preferences (via IUserProfileService), most notably the user's default printer.
Address	Class	SAIF.Data.Model.Contacts	Address models a single postal address record (domestic or foreign) attached to a person or company, carrying up to four free-form address lines, city/state/zip or foreign postal fields, an effective/expiration date range, and active/primary/foreign flags. It derives from CreateAndUpdateTrackingBase<Address>, so every address automatically carries CreateUser/CreateDate/UpdateUser/UpdateDate audit fields, and it links to an AddressCode to classify the address's purpose (e.g. mailing, billing)*.
AddressCode	Class	SAIF.Data.Model.Contacts	AddressCode is a code-table entity that classifies an Address record (e.g. its type or purpose), adding no members of its own beyond what it inherits from CodeTableEntity<AddressCode>.
BusinessOnlineMenuItem	Class	SAIF.Data.Model.Menu	BusinessOnlineMenuItem models a single navigation menu entry for a "Business Online" application/portal, per user (MenuUser), with page routing (PageId, PageLink, PageName), category grouping, sort order, favorite/visibility flags, and tooltip text. It overrides Equals/GetHashCode based on Id and IsFavorite*.
CodeTableEntity<TEntity>	Class	SAIF.Data.Model	CodeTableEntity<TEntity> is the shared abstract base for the framework's many "code table" reference-data entities (for example AddressCode, EmailCode, PhoneCode, DocumentTypeCode, and the imaging/PDF/user status code classes), giving each a uniform Code/Description pair so callers can treat any code-table entity generically. It is a curiously-recurring generic base (TEntity : CodeTableEntity<TEntity>) built on top of EntityBase<TEntity> from the SAIF.Common package*, meaning it inherits that package's entity identity/equality behavior in addition to the members below.
Company	Class	SAIF.Data.Model.Contacts	Company models a business entity contact record — with its own code, name, tax ID, and internal/external reference identifiers — and aggregates the addresses, people, and phone numbers associated with it via ICollection<Address>, ICollection<Person>, and ICollection<Phone>. Its IsPerson flag suggests the same Company table/entity may also represent an individual party in some contexts, alongside true companies*.
CountryCode	Class	SAIF.Data.Model.Contacts	CountryCode is a code-table entity for country reference data, adding no members of its own beyond what it inherits from CodeTableEntity<CountryCode>. Source contains a commented-out IsoAlpha3Code property, indicating an ISO alpha-3 country code field was considered but never implemented*.
CreateAndUpdateTrackingBase<TEntity>	Class	SAIF.Data.Model	CreateAndUpdateTrackingBase<TEntity> is a reusable base class that adds the standard "who/when created and last updated" audit columns to an entity, so domain entities such as Address and Person get consistent create/update tracking without redeclaring the same four properties. Like CodeTableEntity<TEntity>, it is built on EntityBase<TEntity> from the SAIF.Common package*.
DeploymentRequest	Class	SAIF.Data.Model.Deployment	DeploymentRequest models a single request to deploy a previously staged build (DeploymentStagedId) to a set of servers/server groups, capturing scheduling, requester/approver, and UC4 (a batch/job-scheduling system) approval and run tracking, plus the URL of the staging artifact and any target-cleaning instructions. It ties together the deployment approval workflow — request, approval, and UC4-orchestrated execution — for the framework's build-deployment tooling*.
DeploymentResult	Class	SAIF.Data.Model.Deployment	DeploymentResult records the outcome of executing a single deployment target (server) within a DeploymentRequest, capturing the status, any message/error text, and who/when the deployment to that server completed. Each DeploymentRequest can produce multiple DeploymentResult rows, one per targeted server*.
DeploymentStaged	Class	SAIF.Data.Model.Deployment	DeploymentStaged models a build that has been staged for potential deployment, recording the application/build identity (application type/name, build version/label/scope, build definition ID), source-control provenance (changeset ID, source collection/branch URLs — implying a Team Foundation Version Control or Azure DevOps source), and who/when it was staged. DeploymentRequest.DeploymentStagedId references this entity as the build a deployment request targets*.
DocumentTypeCode	Class	SAIF.Data.Model.Printing	DocumentTypeCode (in SAIF.Data.Model.Printing) is a code-table entity classifying an XDocument's document type, adding no members beyond what it inherits from CodeTableEntity<DocumentTypeCode>. It is a separate type from SAIF.Data.Model.Printing.Enums and from the imaging namespace's document-type code classes*.
DuplexModeExtensions	Class	SAIF.Data.Model.Printing	DuplexModeExtensions is a static extension-method class that converts between Enums.DuplexModes values and the fixed-width short codes ("DEFLT", "HORIZ", "VERTL", "SIMPL") used to persist duplex mode as a string on XDocument.DuplexMode/XPrintControl.DuplexMode. Any code or string value not recognized by the switch falls back to Default/"" rather than throwing*.
EmailAddress	Class	SAIF.Data.Model.Contacts	EmailAddress models a single email address record attached to a person or external user, with an active/primary/validated status, an effective/expiration date range, and a classification via EmailCode. Both Person and ExternalUser reference this entity — Person through an ICollection<EmailAddress> and ExternalUser through a single EmailAddress property — showing it is shared across the contact and user sub-domains*.
EmailCode	Class	SAIF.Data.Model.Contacts	EmailCode is a code-table entity that classifies an EmailAddress record, adding no members of its own beyond what it inherits from CodeTableEntity<EmailCode>.
Employee	Class	SAIF.Data.Model.Employees	Employee models an internal employee record — name, contact details (email, phone, fax), job title, department, and physical work location (street/city/state/zip, floor, desk location) — and models the reporting hierarchy via a self-referencing Supervisor property that points to another Employee. EmployeeStatusCode (a plain string field here, not a navigation property) classifies the employee's status*.
EmployeeStatusCode	Class	SAIF.Data.Model.Employees	EmployeeStatusCode is a code-table entity for employee status classification, adding no members of its own beyond what it inherits from CodeTableEntity<EmployeeStatusCode>. WcisEmployee.Status references this type directly as a navigation property, whereas Employee.EmployeeStatusCode stores the equivalent classification as a plain string rather than a reference to this entity*.
Enums (SAIF.Data.Model.Printing)	Class	SAIF.Data.Model.Printing	Enums is a static container class that groups the printing subsystem's two enumerations — DuplexModes and BinTypes — under a single namespace-scoped type rather than declaring them as top-level enums. DuplexModeExtensions and XBinTypeExtensions provide the string-code conversion methods (ToCodeValue/ToEnumValue) that map between these enum values and the short codes (e.g. "DEFLT", "TRAY1") used in XDocument/XPrintControl*.
ExternalUser	Class	SAIF.Data.Model.Users	ExternalUser represents an account for a user outside the organization (a customer, agent, or other external party) accessing a self-service/portal application: it tracks account state (password-change-required, test-user flags, agreement acceptance, authorization, claim ownership, self-registration prevention), lifecycle timestamps (disable date, last logon, profile update, test-user expiration, email-verification expiration), and links to EmailAddress, Person, ExternalUserStatusCode, and a list of ExternalUserType entries describing the roles/affiliations the account holds.
ExternalUserStatusCode	Class	SAIF.Data.Model.Users	ExternalUserStatusCode classifies the status of an ExternalUser account (referenced via ExternalUser.Status), and defines a well-known Deleted constant code value ("DEL") that calling code can compare against directly rather than hardcoding the string*.
ExternalUserType	Class	SAIF.Data.Model.Users	ExternalUserType represents one role/affiliation an ExternalUser holds, linking the user to a customer (CustomerId) and/or customer group (CustomerGroupId), an owning Company, and a classification code (ExternalUserTypeCode). ExternalUser.UserTypes holds a list of these, so a single external user account can carry multiple such affiliations*.
ExternalUserTypeCode	Class	SAIF.Data.Model.Users	ExternalUserTypeCode classifies the kind of affiliation represented by an ExternalUserType record, adding customer-ID and customer-group-ID description text alongside the base Code/Description pair.
Image	Class	SAIF.Data.Model.Imaging	Image models a scanned/imaged document record linked to a claim (ClaimNumber) and policy (PolicyNumber)/TOW record (TowId), carrying a numeric security level, a discoverability flag (for legal/e-discovery purposes), classification via ImageSystem/ImageDocumentTypeCode/ImageCategoryCode/ImageDocumentNameCode, and a collection of related ImageAffiliation links to other images. Its ConfidentialSecurityLevel/NonConfidentialSecurityLevel constants define the two ends of the security-level scale used by SecurityLevel*.
ImageAffiliation	Class	SAIF.Data.Model.Imaging	ImageAffiliation represents a link between one Image and another related image (identified by AffiliationImageId), recording who created the link and when. Image.ImageAffiliations holds the collection of these links for a given image, so an image can be affiliated with (associated to) other images without being merged into a single record*.
ImageCategoryCode	Class	SAIF.Data.Model.Imaging	ImageCategoryCode is a code-table entity classifying an image's category, extending the base Code/Description with a FileCode, an external-facing description, an "display in add-ins" flag, and the set of ImageDocumentTypeCode types that belong to this category. It overrides Equals/GetHashCode to compare by the combination of FileCode and Code rather than by reference or by Code alone*.
ImageDocumentNameCode	Class	SAIF.Data.Model.Imaging	ImageDocumentNameCode is a code-table entity classifying an image's document name, extending the base Code/Description with an image-system file code, an internal description, and denormalized category/document-type code references stored as plain strings (rather than navigation properties). Source retains a large commented-out block for a category/document-type-aware Equals/GetHashCode override that was never enabled*.
ImageDocumentNameGCode	Class	SAIF.Data.Model.Imaging	ImageDocumentNameGCode is a globalized/culture-specific counterpart to ImageDocumentNameCode: it adds a CultureCode alongside the same image-file/category/document-type string references, so document names can be localized per culture ("G" denoting the globalization variant)*.
ImageDocumentTypeCode	Class	SAIF.Data.Model.Imaging	ImageDocumentTypeCode is a code-table entity classifying an image's document type, adding default confidentiality/discoverability flags (IsConfidentialByDefault, IsDiscoverableByDefault), UI display control (DisplayInAddins), a default external view code, an external description, a sort order, an optional expiration date, and a reference to its owning ImageCategoryCode. It overrides Equals/GetHashCode to compare by category plus code*.
ImageDocumentTypeGCode	Class	SAIF.Data.Model.Imaging	ImageDocumentTypeGCode is the globalized/culture-specific counterpart to ImageDocumentTypeCode, carrying an ImageFileCode, CultureCode, and CategoryCode alongside the inherited Code/Description. It overrides Equals/GetHashCode to compare by the full combination of code, image file code, culture code, and category code*.
ImageDocumentTypeGroupCode	Class	SAIF.Data.Model.Imaging	ImageDocumentTypeGroupCode is a code-table entity representing a higher-level grouping of document types (corresponding to Image.DocumentTypeGroup), adding a UI-display flag and a Code-based GetHashCode override*.
ImageExternalViewCode	Class	SAIF.Data.Model.Imaging	ImageExternalViewCode is a code-table entity corresponding to Image.ExternalViewCode, adding a NumDaysPending field that controls how long an image stays in a pending state before becoming externally visible under this view code. It overrides Equals/GetHashCode based on Code*.
ImageSystem	Class	SAIF.Data.Model.Imaging	ImageSystem represents the source imaging-system record an Image was scanned/ingested through, carrying IFN (image file number) disk-set/file identifiers, page count, batch/security metadata, and scan/update timestamps, plus the collection of Image records it produced. Image.ImageSystem references this entity to trace an image back to its originating scan batch*.
IQueryProvider	Interface	SAIF.Data.Queries	IQueryProvider (in the SAIF.Data.Queries namespace) is an intentionally empty marker interface used to tag query-provider types so they can be identified and grouped (for example by dependency-injection registration or type scanning) without exposing any shared method surface*. QueryProviderBase is the sole implementer in this library and supplies the actual common behavior (repository-factory access) that concrete query providers build on.
IRepository<TEntity>	Interface	SAIF.Data	IRepository<TEntity> is the generic persistence contract that every entity type in SAIF.Data.Model is accessed through: it defines CRUD-style operations (Add, Update, Delete, Get, Load) plus a queryable surface (Query()) for a single entity type, so business/service code depends only on this interface rather than a concrete ORM or database technology. The only concrete implementation shipped in this library, SAIF.Data.TestRepository.TestRepository<TEntity>, is an in-memory list-backed test double used to exercise consumers without a real database*.
IRepositoryFactory	Interface	SAIF.Data	IRepositoryFactory is the narrow factory contract that resolves a typed IRepository<TEntity> for any entity implementing IDataEntity; IUnitOfWork extends this interface so that a single unit of work doubles as the repository factory for everything it touches, keeping repository creation and transactional scope tied together. SAIF.Data.Queries.QueryProviderBase depends on this interface (not the wider IUnitOfWork) as its minimal collaborator, showing that query providers only need repository resolution, not transaction control.
ISessionHelper	Interface	SAIF.Data	ISessionHelper is a minimal abstraction over "current session time" that lets data-layer and business-logic code ask for the effective system date without depending on DateTime.Now directly, so a caller can substitute a controlled or test-specific clock behind the interface*. SAIF.Data.TestRepository.TestUnitOfWork exposes an implementation (TestSessionHelper) that simply returns DateTime.Now, confirming the interface's role as a swappable time source for units of work.
ITestRepository	Interface	SAIF.Data.TestRepository	ITestRepository is an intentionally empty marker interface implemented by TestRepository<TEntity>, used so TestUnitOfWork can hold a non-generic Dictionary<Type, ITestRepository> cache of repositories of differing generic types without needing a common generic base*.
IUnitOfWork	Interface	SAIF.Data	IUnitOfWork is the framework's central data-access abstraction: it combines transactional lifecycle control (Begin/Commit/Rollback/Dispose) with repository resolution (via IRepositoryFactory), so consuming code obtains typed IRepository<TEntity> instances and commits or rolls back their combined changes as a single unit, without depending on a concrete persistence technology. The only concrete implementation in this library, SAIF.Data.TestRepository.TestUnitOfWork, is an in-memory test double that treats Begin/Commit/Rollback/Dispose as no-ops and backs repositories with in-memory lists — there is no real database connection or transaction behind it in this library*.
PDFApplicationErrorCode	Class	SAIF.Data.Model.PDF	PDFApplicationErrorCode records a PDF-processing application error code along with the support team responsible for it and a subject line to use for HEAT (an IT service-desk/ticketing system) email notifications, plus create audit fields. PDFTracking.ApplicationError references this entity to record which known error, if any, occurred while generating a tracked PDF*.
PDFCache	Class	SAIF.Data.Model.PDF	PDFCache records a cached copy of a generated/converted PDF file, keyed by a processing identifier (ProcessId) and linked to its source TOW/IFN disk-set/IFN identifiers, with the on-disk cache path, original file extension, and a flag indicating whether the source was already a "tower" (system-native) PDF. It exists to avoid re-generating the same PDF conversion repeatedly*.
PDFCacheProcess	Class	SAIF.Data.Model.PDF	PDFCacheProcess tracks the execution of a batch PDF-caching process — its priority, source batch, status (PDFStatusCode), start/end timestamps, and any status message — for a specific TOW/IFN document. It is declared as EntityBase<PDFCacheRequest> rather than EntityBase<PDFCacheProcess> in source, an apparent copy-paste artifact from the near-identical PDFCacheRequest class it was likely derived from*.
PDFCacheRequest	Class	SAIF.Data.Model.PDF	PDFCacheRequest represents a single request to generate/cache a PDF for a specific TOW/IFN document, carrying batch grouping, priority, current status (PDFStatusCode), a status message, and create/update audit fields. It is structurally almost identical to PDFCacheProcess but omits the StartDate/EndDate execution-window fields, positioning it as the incoming request record that PDFCacheProcess then tracks execution for*.
PDFStatusCode	Class	SAIF.Data.Model.PDF	PDFStatusCode represents the status of a PDF cache/tracking process (e.g. queued, in progress, completed, failed), referenced by PDFCacheProcess.Status, PDFCacheRequest.Status, and PDFTracking.StatusCode*.
PDFTracking	Class	SAIF.Data.Model.PDF	PDFTracking (the SAIF.Data.Model.PDF entity — distinct from the unrelated SAIF.Core.Contracts.PDF.PDFTracking contract type) records the full lifecycle of one PDF-generation job: its tracking/status/application-error classification, output file location and naming (FileId/FilePrefix/OutputFilePath), processing window, a purge date for eventual cleanup, PDF/A compliance flag, source-system identifier, and create/update audit fields. It links to PDFTrackingCode, PDFStatusCode, and PDFApplicationErrorCode to classify what kind of job it is, what its current status is, and what error (if any) occurred.
PDFTrackingCode	Class	SAIF.Data.Model.PDF	PDFTrackingCode classifies the type of PDF-generation job represented by a PDFTracking record (via PDFTracking.TrackingCode), with a code and description.
Person	Class	SAIF.Data.Model.Contacts	Person models an individual party in the contact data model, capturing name variants (legal, alias, maiden, married, nickname, preferred), demographic fields (birth date, gender code, ethnic group code, anniversary date), identification (driver's license number/state, tax ID), and active/primary status. It derives from CreateAndUpdateTrackingBase<Person> for audit tracking, and aggregates the person's addresses, email addresses, and phone numbers via ICollection<Address>, ICollection<EmailAddress>, and ICollection<Phone>*.
Phone	Class	SAIF.Data.Model.Contacts	Phone models a single phone number record attached to a person or company, split into area code/prefix/number/extension/country-code parts, with active/primary/foreign/long-distance flags, an effective/expiration date range, and a classification via PhoneCode.
PhoneCode	Class	SAIF.Data.Model.Contacts	PhoneCode is a code-table entity that classifies a Phone record, adding no members of its own beyond what it inherits from CodeTableEntity<PhoneCode>.
Preference	Class	SAIF.Data.Model.Preferences	Preference stores a single per-user, per-application, per-page piece of saved preference data as free text (PreferenceText), allowing applications to persist arbitrary UI/behavior settings for a user without a dedicated schema for each setting*.
QueryProviderBase	Class	SAIF.Data.Queries	QueryProviderBase is the abstract base for query-provider classes: it implements the empty IQueryProvider marker interface and supplies the one thing every query provider needs — access to an IRepositoryFactory for resolving repositories — via a protected, constructor-injected Factory property. It validates its constructor argument with Enforce.ArgumentNotNull, a SAIF.Common guard helper*, so a query provider cannot be constructed without a valid repository factory.
StateCode	Class	SAIF.Data.Model.Contacts	StateCode is a code-table entity for US state/province reference data that extends the base Code/Description pair with NCCI (National Council on Compensation Insurance) workers'-compensation-related fields — an NCCI state code and configured retro/waiting periods — indicating this entity backs workers'-compensation rating and policy logic rather than being a purely generic address lookup*.
TestRepository<TEntity>	Class	SAIF.Data.TestRepository	TestRepository<TEntity> is the library's only concrete IRepository<TEntity> implementation, and it is an in-memory test double, not a database-backed repository: it stores entities in a private List<TEntity> and implements Add/Update/Delete/Get/Load/Query entirely against that in-memory list. It exists so that consumers of IRepository<TEntity> (and, by extension, IUnitOfWork) can be unit tested without a real data store. It optionally auto-generates a long-typed primary key via reflection when entities are added, using an internal LongSequence generator.
TestUnitOfWork	Class	SAIF.Data.TestRepository	TestUnitOfWork is the library's only concrete IUnitOfWork implementation, and it is an in-memory test double rather than a real transactional/database unit of work: Begin, Commit, and Rollback are no-ops, and GetRepository<TEntity> lazily creates and caches a TestRepository<TEntity> per entity type in an internal dictionary keyed by Type. It pairs with an internal TestSessionHelper (exposed via its SessionHelper property) that returns the live system clock. This is the composition root consumers use in tests to exercise code written against IUnitOfWork/IRepository<TEntity> without any real data store*.
TrueFalseUnknown	Class	SAIF.Data.Model	TrueFalseUnknown is a three-state boolean enum (Unknown, True, False) that represents fields where a plain boolean cannot distinguish "not yet determined" from an explicit false value*. It gives domain models in SAIF.Data.Model a way to express tri-state flags without resorting to bool? and its null-handling ambiguity.
WcisEmployee	Class	SAIF.Data.Model.Employees	WcisEmployee (declared as WcisEmployee in source, despite the task's approximate WCISEmployee naming) is a lighter-weight employee record than Employee, holding just name, phone, title, and a Status navigation property to EmployeeStatusCode. The "WCIS" prefix suggests this entity models employee data specifically for a WCIS (Workers' Compensation Insurance System/reporting) integration or feed, distinct from the general-purpose Employee entity*.
WebContextItem	Class	SAIF.Data.Model.WebContext	WebContextItem stores a single named piece of contextual state for a web application, scoped to a session (SessionId) and application (ApplicationName), as a name/value pair (ContextName/ContextValue). It provides a database-backed alternative to in-process session state for web applications that need to persist or share context values across requests or servers*.
XBinTypeCode	Class	SAIF.Data.Model.Printing	XBinTypeCode is a code-table entity classifying a printer's paper-bin/tray type, adding no members beyond what it inherits from CodeTableEntity<XBinTypeCode>. It represents the same concept as Enums.BinTypes, but as a persisted code-table row rather than an in-memory enum.
XBinTypeExtensions	Class	SAIF.Data.Model.Printing	XBinTypeExtensions is a static extension-method class that converts between Enums.BinTypes values and the fixed-width short codes ("AUTO", "BULK", "ENVLP", "TRAY1"–"TRAY4") used to persist bin/tray selection as a string in the printing data model. Unrecognized codes/values fall back to AutoSelect/"" rather than throwing*.
XDocument	Class	SAIF.Data.Model.Printing	XDocument (in SAIF.Data.Model.Printing — distinct from System.Xml.Linq.XDocument) represents a single document to be printed, faxed, or emailed as part of a print job controlled by an XPrintControl: it carries the target bin type and duplex mode (as string codes), document type, output destination (file name, email address, fax number), an "IDX contents" text block, print-group/start-value routing hints, a copies count, and up to ten generic sort-value fields used for print sequencing.
XPrintControl	Class	SAIF.Data.Model.Printing	XPrintControl represents a single print job/control record: it identifies the generated print-definition XML file (XmlFileName, DirectoryName), an MD5 hash of that file's contents for change detection, processing/creation timestamps, a default duplex mode, and the collection of XDocument records (initialized eagerly in its constructor) that make up the job.
MissingDependencyException	Class	SAIF.Exceptions	MissingDependencyException signals that code attempting to manually resolve a dependency (rather than have it injected through a constructor) found nothing registered for the requested name. It exists specifically for the manual-resolution code path in this library and its consumers — constructor injection failures are instead surfaced by the DI container itself, not by this type.* The exception message is built from the caller-supplied dependency name at construction time, so callers get an immediate, specific diagnostic ("The required {dependencyName} has not been registered and cannot be retrieved.") rather than a generic null-reference or container error.
MissingEnvironmentUrlVariableException	Class	SAIF.Exceptions	MissingEnvironmentUrlVariableException is thrown by EnvironmentServiceBase when its EnvironmentApiUrl property is accessed but the required OS-level environment variable EnvironmentApiUrl was empty or missing at construction time (see Configuration settings). Because every concrete IEnvironmentService implementation in this library derives from EnvironmentServiceBase, this exception is the hard failure mode for any application built on the framework as soon as it attempts a settings-driven operation — GetConfigSetting, LoadSection, GetGlobalConfigSettings, and GetSecureConfigSetting all depend on a resolved EnvironmentApiUrl and will fail with this exception if the variable was never set on the host machine. It has a fixed, parameterless message and carries no additional diagnostic data beyond that message.
MissingUserDomainException	Class	SAIF.Exceptions	MissingUserDomainException is documented, per its source XML comment, as being thrown by SecurityApiClient when a user request is made without providing a domain — i.e. a username that does not follow the domain\username format required by the Security API client (see BR-CORE-05 Security API username format requirement). No call sites for this exception were found within this library's SecurityApiClient implementation, which instead validates the domain\username format via TryParseDomainUsername and raises ArgumentException/ArgumentNullException on malformed or missing input (see BR-CORE-12 Security API request pre-validation).** This exception is retained in the public API for consumers that perform their own domain-format validation ahead of calling the Security API client.
ActiveDirectoryServiceProxy	Class	SAIF.Services.ClientProxies	ActiveDirectoryServiceProxy is an internal legacy client wrapping the older SOAP-based clsADServicesSoapClient web service (SAIF.Core.Legacy.ActiveDirectory), exposing default-printer lookup, cached role-membership checks, and a mapped Contact projection of AD user info.
ApplicationExceptionDetailExtensions	Class	SAIF.Services.Extensions	ApplicationExceptionDetailExtensions is an internal static extension class that adds a single mapping method to ApplicationExceptionDetail, converting it into the ErrorDetail struct expected by the Core.LoggingApi contracts layer.
DateExtensions	Class	SAIF.Services.Extensions	DateExtensions is a static extension class on DateTime providing legacy working-day calculations (via a private static WorkCalendarService instance). Every public member is marked [Obsolete(..., true)], meaning calls to them fail to compile — the class is retained for source compatibility while steering all new code toward an injected IWorkCalendarService.
DbConnectionServiceProxy	Class	SAIF.Services.ClientProxies.Legacy	DbConnectionServiceProxy is a legacy public client wrapping the SOAP-based ConnectInfoSoapClient web service (SAIF.Core.Legacy.DbConnection), used to obtain fully-formed Oracle or SQL Server connection strings for a given database instance and user, attributing the request to the current OS username.
DocumentServiceProxy	Class	SAIF.Services.ClientProxies	DocumentServiceProxy is an internal legacy client wrapping the SOAP-based clsGenerateSoapClient "xPression Design" document-generation web service, providing document preview, category/package lookups, and multiple document-distribution/print entry points that map this library's config/model types onto the legacy service's enum and struct shapes.
FaxServiceClient	Class	SAIF.Services.ClientProxies	FaxServiceClient is a WCF client proxy that implements IFaxService over a BasicHttpBinding channel, exposing the fax-service SendFax operation to consumers while configuring the binding for large messages (unbounded message size, buffer size, and array length) needed to transmit fax documents and cover sheets.
FaxServiceProxy	Class	SAIF.Services.Web.Proxies	FaxServiceProxy is a legacy public client wrapping the SOAP-based FaxServiceSoapClient web service (SAIF.Services.Web.Proxies.Fax), sending a single fax attachment to a recipient over a Windows-authenticated (TransportCredentialOnly) HTTP binding. Note this type lives in the SAIF.Services.Web.Proxies namespace, not SAIF.Services.ClientProxies/.Legacy, despite sitting in the ClientProxies\Legacy source folder.
FileServiceClient	Class	SAIF.Services.ClientProxies	FileServiceClient is an internal WCF client proxy implementing IFileService over BasicHttpBinding, providing byte-level file read/write/delete/length operations against a remote file service. It is declared internal, so it is not directly consumable outside this assembly; consumers should obtain file functionality through the higher-level WcfContracts.IFileService registration in ServiceRegistrations.
Helpers	Class	SAIF.Services.ClientProxies	Helpers is an internal static utility class in the legacy client-proxy code path providing a single generic enum-mapping method, MapEnumByName, used by DocumentServiceProxy to translate this library's PlexMode/ScaleMode/PaperTray enums into the equivalent enum members expected by the legacy clsGenerateSoapClient document-generation service.
ImagingServiceClient	Class	SAIF.Services.ClientProxies	ImagingServiceClient is an internal WCF client proxy implementing IImagingService over BasicHttpBinding, used to queue document images for processing and to reserve image identifiers ahead of an upload. It is declared internal, so external consumers reach imaging functionality only through the IImagingService registration in ServiceRegistrations.
IValidationServiceExtensions	Interface	SAIF.Services.Extensions	IValidationServiceExtensions is a static extension class on IValidationService that adds ValidateAndAddErrors<T>, a convenience method combining a validation call with population of an IMessageContainer, so callers of a ValidatingServiceBase-derived service can validate an instance and surface its errors in one step.
LoggingServiceProxy	Class	SAIF.Services.ClientProxies	LoggingServiceProxy is a legacy public client marked [Obsolete("The LoggingServiceProxy is no longer in use. Please use SAIF.Services.Utilities.LogService.")]. Its constructor validates the supplied serviceUrl but its underlying SOAP client field and web-service call are commented out in source, so LogException is currently a no-op.
OpenTelemetryExtensions	Class	SAIF.Services	OpenTelemetryExtensions is a static class providing an Autofac ContainerBuilder extension, ConfigureOpenTelemetry, plus supporting factory methods, that wires up OpenTelemetry logging, tracing, and metrics providers with SAIF-specific resource attributes (owner, host IPs, IIS app-pool ID, process start time) and conditionally enables an OTLP exporter based on the OTEL_EXPORTER_OTLP_ENDPOINT environment variable.
OpenTelemetryOptions	Class	SAIF.Services	OpenTelemetryOptions is a plain options class consumed by OpenTelemetryExtensions.ConfigureOpenTelemetry, currently exposing a single Owner setting that is written into the OpenTelemetry Resource's owner attribute (lowercased) to identify the team/service owner in exported telemetry.
PdfServiceClient	Class	SAIF.Services.ClientProxies	PdfServiceClient is a WCF client proxy implementing IPdfService over BasicHttpBinding, exposing PDF inspection (page count, version, IsPdf), conversion, and merge/extract operations, plus a Ping health check, to consumers.
PdfServiceProxy	Class	SAIF.Services.ClientProxies	PdfServiceProxy is an internal legacy client wrapping the SOAP-based PDFServiceClient (SAIF.Core.Legacy.PDF), retrieving a single cached PDF image by sequence number using the legacy image-caching protocol (PDFCacheArgs/LoadCache) with fixed high-priority, immediate-processing cache settings.
PreferenceServiceClient	Class	SAIF.Services.ClientProxies	PreferenceServiceClient is an internal WCF client proxy implementing IPreferenceService over a default BasicHttpBinding, providing per-application/page/user preference storage and retrieval, and default-printer lookup. It is declared internal; external consumers reach preference functionality through the IPreferenceService registration in ServiceRegistrations.
SecurityGroupService	Class	SAIF.Services	SecurityGroupService implements ISecurityGroupService and exposes a focused subset of the WCF SecurityService's Active Directory group-membership functionality to framework consumers, normalizing "resource" naming conventions before delegating to the internal SecurityServiceClient proxy. For the environment-suffix normalization logic used by GetMembersByResource, see the SecurityGroupService.GetMembersByResource operation.
SecurityServiceClient	Class	SAIF.Services.ClientProxies	SecurityServiceClient is an internal WCF client proxy implementing ISecurityService, fronting the WCF security service referenced by the securityServiceUrl environment-service configuration key. Its own doc comment states it "should not be exposed directly to callers" — instead, callers should use higher-level wrappers such as SecurityGroupService and SystemUserProfile. It exposes authorization checks, AD user lookups, and group-membership queries.
ServiceBase	Class	SAIF.Services	ServiceBase is the root abstract marker class for platform services registered through ServiceRegistrations — it implements the empty IService marker interface and exists so consuming code and the Autofac composition root can identify a type as a SAIF platform service without imposing any behavior of its own.
ServiceRegistrations	Class	SAIF.Services	ServiceRegistrations is the static Autofac composition root for this library. It exposes two public entry points — one for web applications, one for Windows/console applications — that populate a consuming application's ContainerBuilder with every platform-service interface implemented by this library, plus every FluentValidation validator discovered in the assembly. For the full step-by-step registration flow, see the ServiceRegistrations.RegisterCoreServicesForWeb / RegisterCoreServicesForWindows operation.
UC4ServiceClient	Class	SAIF.Services.ClientProxies	UC4ServiceClient is a REST client (not a WCF proxy, unlike its siblings in this namespace) that schedules jobs on the UC4 job-scheduling system by issuing an NTLM-authenticated HTTP POST via RestSharp, attaching caller-identifying headers (application-id, client-name, client-user) from a supplied ClientInfo.
ValidatingServiceBase	Class	SAIF.Services	ValidatingServiceBase extends ServiceBase to add a settable MessageContainer, giving derived platform services a standard place to accumulate validation errors, warnings, and informational messages produced while performing their work, per the IValidatingService contract.
ValidatorFactory	Class	SAIF.Services	ValidatorFactory implements FluentValidation's IValidatorFactory by resolving IValidator<T> (or a runtime-typed IValidator) through an injected Autofac IComponentContext, letting callers such as FluentValidationService obtain the correct registered validator for a given model type without a static service-locator lookup.
WorkCalendarServiceProxy	Class	SAIF.Services.ClientProxies	WorkCalendarServiceProxy is an internal legacy client wrapping the SOAP-based SAIFDatesSoapClient web service (SAIF.Core.Legacy.WorkCalendar), providing working-day calculations (first/last/next working day, working-day check) for a named calendar. It is superseded by the injectable IWorkCalendarService/WorkCalendarService used by DateExtensions and elsewhere in the codebase.*
Constants	Class	SAIF.Services.Common	Constants is a small public holder class declaring the GlobalSection literal used throughout EnvironmentServiceBase to identify the "global" configuration section — the section consulted when a configuration key has no dot-qualified section prefix.
CustomEnvironmentService	Class	SAIF.Services.Common	CustomEnvironmentService is the EnvironmentServiceBase subclass for callers that need to explicitly select a host/environment rather than have it auto-detected — for example test harnesses, batch jobs, or tooling that must target a specific track host. Unlike the other concrete environment services, its ApplicationHost is fixed at construction (either a caller-supplied host string or one mapped from a CustomEnvironment enum value) and never re-resolved dynamically.
DbConnectionManager	Class	SAIF.Services.Common	DbConnectionManager is a static facade that resolves live database connection strings on demand through a legacy DbConnectionServiceProxy (ASMX/WCF client), indirected through an IEnvironmentService configuration key. It caches resolved connection strings in-process so repeated calls for the same instance/server/user combination avoid re-querying the legacy connection-info service; see Configuration.
EnvironmentConfigKeys	Class	SAIF.Services.Common	EnvironmentConfigKeys is a static class of const string Environment API configuration key names, giving downstream consumers compile-time-checked keys to pass to IEnvironmentService.GetConfigSetting instead of hand-typed string literals. See Configuration for which constants are actually consumed within this library versus retained for downstream use only.
EnvironmentHost	Class	SAIF.Services.Common	EnvironmentHost resolves a request URI's host into the short, domain-stripped, port-suffixed form used as the ApplicationHost convention across the Environment API — used internally by WebEnvironmentService and WcfEnvironmentService when a request URI, rather than a developer/local-machine fallback, determines the current host.
EnvironmentServiceBase	Class	SAIF.Services.Common	EnvironmentServiceBase is the abstract implementation of IEnvironmentService that every concrete environment service (WindowsEnvironmentService, WebEnvironmentService, WcfEnvironmentService, CustomEnvironmentService) derives from. It owns configuration retrieval (with developer-override, in-memory-cache, and Environment API precedence, see BR-CORE-04), developer-machine detection (see BR-CORE-03), staleness-based refresh of cached settings, and secure-setting retrieval backed by a SecureSettingCache. Concrete subclasses only need to supply host/machine-identity abstractions (ApplicationHost, MachineName, IsClientExternal, etc.).
ImageConfigExtensions	Class	SAIF.Services.Common	ImageConfigExtensions is a static extension-method class that serializes an ImageConfig (and optionally an associated ImageTaskConfig) into the flat KEY=VALUE line-per-setting text format ("IDX file") consumed by the legacy imaging/indexing pipeline.
IWebEnvironmentService	Interface	SAIF.Services.Common	IWebEnvironmentService is a narrow interface exposing the web-relevant subset of the EnvironmentServiceBase surface (client classification, identity, and plain configuration retrieval) for consumers that need to depend on an abstraction rather than the concrete WebEnvironmentService class. WebEnvironmentService is the sole implementer in this library.
PropertiesFileUtilities	Class	SAIF.Services.Common	PropertiesFileUtilities is a static, ASP.NET-only utility for reading values out of a legacy Xml\Properties.xml file located at the application's physical root, using XPath expressions. It has no call sites within this library itself — it exists as a directly usable helper for consuming web applications; see Configuration.
SecureSettingCache	Class	SAIF.Services.Common	SecureSettingCache is the in-process cache backing EnvironmentServiceBase.GetSecureConfigSetting/GetSecureConfigSetting<T>. It memoizes the result of an expensive fetch (an encrypted/credential setting call to the Environment API) per key, and re-fetches only when the caller-supplied lastRefreshed timestamp is newer than the cached item's fetch time — the same staleness signal used by EnvironmentServiceBase.LastRefreshed.
SystemHashUtil	Class	SAIF.Services.Common	SystemHashUtil generates and validates the SHA-256-based "system hash" identifier used by EnvironmentServiceBase.GetSecureConfigSetting (as the systemHashValue query parameter) and by the Environment API's GetSystemHash route to identify which application/system is requesting a secure setting. It also resolves the entry assembly for the current process across console, legacy web, and modern web hosting scenarios.
WcfEnvironmentService	Class	SAIF.Services.Common	WcfEnvironmentService is the EnvironmentServiceBase subclass for WCF service hosts. It derives its application identity from the inbound RequestContext's destination URI and resolves ApplicationHost from that same URI via EnvironmentHost, following the same developer-machine/local-machine precedence used by WebEnvironmentService.
WebEnvironmentService	Class	SAIF.Services.Common	WebEnvironmentService is the EnvironmentServiceBase subclass for ASP.NET web applications. It derives its application identity and default directory from the current HttpContextBase, resolves ApplicationHost using the current request URL (via EnvironmentHost), and determines client-network classification (IsClientExternal, IsClientInsideFirewall) by comparing the requesting client's IP address against configured address-root lists.
WindowsEnvironmentService	Class	SAIF.Services.Common	WindowsEnvironmentService is the EnvironmentServiceBase subclass for non-web, non-WCF hosts (console apps, Windows services). It derives its application identity from the entry assembly and resolves its ApplicationHost by matching a path segment of the running executable's command line or assembly location against the set of known track hosts fetched from the Environment API, falling back to a developer host or the local machine name.
ApplicationUserProfile	Class	SAIF.Services.Utilities.UserProfile	ApplicationUserProfile implements IApplicationUserProfile by extending ApplicationUserProfileBase<T> closed over WcfContracts.User (the base WCF security-service user contract). It represents a generic authenticated application user and is instantiated exclusively through its static GetByUserId factory, which resolves the underlying User from the WCF SecurityServiceClient and falls back to an empty user (Id = "") if none is found.
ApplicationUserProfileBase<T>	Class	SAIF.Services.Utilities.UserProfile	ApplicationUserProfileBase<T> is an abstract class implementing IApplicationUserProfile that extends SystemUserProfile, adding a strongly-typed wrapped WCF user contract (T, constrained to WcfContracts.User) and exposing its account-state fields (domain, locked/active/external/test flags, password-change flag, last login) as pass-through properties. It also constructs the user's Contact and Preferences (via Preferences) at construction time. It is the shared base for ApplicationUserProfile, ExternalUserProfile, and SaifUserProfile, each closing over a more specific WCF user contract type.
DocumentHelper	Class	SAIF.Services.Utilities.Documents	DocumentHelper is an internal** static helper class in the Documents namespace that centralizes two small, environment-dependent constants used when generating documents: the third-party imaging application name required by an external library, and the document profile name to use based on production/non-production status. It is consumed by PrintService to select the correct document profile.
DocumentService	Class	SAIF.Services.Utilities.Documents	DocumentService implements IDocumentService and IDisposable, fronting a remote WCF DocumentServiceProxy (see SAIF.Services.ClientProxies) whose endpoint is resolved from the documentGeneratorServiceUrl environment setting. It generates/previews PDF documents from named templates ("packages") merged with XML data, and distributes generated documents to email, imaging, fax, and print destinations in a single call, combining an injected EmailService, ImagingService, PrintService, and FaxService/IPdfService as its sub-service properties.
DomainUser	Class	SAIF.Services.Utilities	DomainUser is an internal** helper data holder used by SecurityApiClient to carry the parsed domain and username segments extracted from a domain\username-formatted string. It is not part of the library's public API surface but is documented here because it is directly involved in enforcing BR-CORE-05.
EmailService	Class	SAIF.Services.Utilities	EmailService implements IEmailService and sends outbound mail using the .NET System.Net.Mail.SmtpClient, targeting an SMTP relay resolved once at construction time from the SMTP_SERVER app-setting (falling back to mail.saif.com if unset). It has no dependency on any other SAIF service — it is the library's only direct-SMTP mail sender, as distinct from the WCF/document-generation mail paths used by DocumentService.
ExternalUserProfile	Class	SAIF.Services.Utilities.UserProfile	ExternalUserProfile implements IExternalUserProfile and IExternalTestUserProfile by extending ApplicationUserProfileBase<T> closed over WcfContracts.ExternalUser. It represents an externally-facing user (e.g., an injured worker or business partner) and adds agreement-acceptance, production-access, expiration, and user-type fields, plus a formatted LastLoginMessage that differs based on whether the user is an injured worker. Instances are created only through its static factory methods, each resolving the underlying ExternalUser via a different WCF SecurityServiceClient lookup.
FaxService	Class	SAIF.Services.Utilities.Documents	FaxService implements IFaxService and validates a FaxConfig via an injected IValidationService (typically FluentValidationService) before dispatching the job to a remote WCF FaxServiceClient (see SAIF.Services.ClientProxies) whose endpoint is resolved from the faxServiceUrl environment setting. Its nested FaxConfigValidator/FaxRecipientValidator FluentValidation validators enforce that the file and recipients are present and that each recipient has a fax number and name (BR-CORE-07 through BR-CORE-10). For the full step-by-step trace, see the FaxService.SendFax operation page.
FileService	Class	SAIF.Services.Utilities	FileService implements IFileService, fronting a remote WCF FileServiceClient (see SAIF.Services.ClientProxies) whose endpoint is resolved from the fileServiceUrl environment setting at construction time. It provides byte-oriented remote file operations (partial/whole read, write, delete, length) rather than local System.IO access, delegating each call to a freshly created, disposed-per-call proxy client.
FluentValidationService	Class	SAIF.Services.Utilities	FluentValidationService implements IValidationService, resolving a FluentValidation IValidator<T> per entity type via an injected IValidatorFactory and mapping FluentValidation's result types into this library's own SAIF.Core.Contracts.ValidationResult/ValidationFailure types. On every single-argument Validate<T>(T) call it additionally always executes the "AuthorizationRules" rule set on the same entity as a side effect — see BR-CORE-11 — though that second result is discarded and not reflected in the returned ValidationResult. For the full step-by-step trace of this behavior, see the FluentValidationService.Validate / ValidateAndThrow operation page.
ImagingService	Class	SAIF.Services.Utilities.Documents	ImagingService implements IImagingService, fronting three distinct remote endpoints resolved from environment settings at construction time: a legacy Oracle-backed PdfServiceProxy (legacyPdfServiceUrl + oracleDatabase), a WCF ImagingServiceClient (imagingServiceUrl) for queueing/reserving images, and a separate WCF32 ImagingServiceClient (towerInfoServiceUrl/towerinfoserviceurl) for tower/IFN-based file lookups. It is the service consulted by PdfConvertAndMergeService to reserve image ids for the activePDF-hosted conversion pipeline.
LogService	Class	SAIF.Services.Utilities	LogService implements ILogServiceForApi, providing this library's tracing/exception-logging facade. It layers a lazily-initialized log4net ILog tracer (configured with a RestApiAppender that ships rendered log events to a remote logging API) together with an optional OpenTelemetry Logger (supplied via a LoggerProvider), so each trace/exception call can emit to both channels. The remote logging endpoint and error-route path are resolved from environment configuration keys under tracingDefaults/TracingDefaults.
MergeFile	Class	SAIF.Services.Utilities.Documents	MergeFile is a public class (not behind an interface) that builds the textual .merge manifest file consumed by the activePDF-hosted PdfMergeConverter service. The generated file must be written to \\activepdf\pdfdata\merge\in, per the type's own XML-doc comment. It is used by PdfConvertAndMergeService to describe a merge job's file/image entries before the merge is scheduled.
PdfConvertAndMergeService	Class	SAIF.Services.Utilities.Documents	PdfConvertAndMergeService is not registered behind a public interface — it is a concrete class that manages creation and disk-writing of the input files needed by the external activepdf-hosted PDFConverter and PDFMergeConverter services, and creates a PDFTracking database record (via IUnitOfWork/IRepository<T>) to track each scheduled conversion or merge job. It is the library's clearest example of a database read/write against PDFTracking/PDFApplicationErrorCode/PDFTrackingCode/PDFStatusCode. For the full step-by-step trace and process-flow diagram, see the PdfConvertAndMergeService.ConvertAysnc / MergeAysnc operation page.
PDFService	Class	SAIF.Services.Utilities.Documents	PdfService (source file PDFService.cs) implements IPdfService, fronting a remote WCF PdfServiceClient (see SAIF.Services.ClientProxies) whose endpoint is resolved from EnvironmentConfigKeys.PdfServiceUrl, for conversion, format conversion, merge, extract, page-count, version, and PDF-detection operations. For the tracked convert/merge workflow, it constructs and delegates to a fresh PdfConvertAndMergeService instance (built from its own injected IUnitOfWork and IEnvironmentService) on each call.
Preferences	Class	SAIF.Services.Utilities.UserProfile	Preferences implements IPreferences, providing a per-user preferences façade over an injected PreferenceService (IPreferenceService). It is constructed internally by ApplicationUserProfileBase<T> with the profile's user id, and exposes get/save/clear operations plus the user's default printer.
PreferenceService	Class	SAIF.Services.Utilities	PreferenceService implements IPreferenceService, fronting a remote WCF PreferenceServiceClient (see SAIF.Services.ClientProxies) whose endpoint is resolved from the preferenceServiceUrl environment setting. It stores per-user, per-application/page preference dictionaries and captures the current user (environmentService.UserId()) at construction time to stamp as the "saved by" user on write operations. It is the backing store consumed by Preferences, the per-user-profile preferences façade.
PrintService	Class	SAIF.Services.Utilities.Documents	PrintService implements IPrintService and IDisposable, fronting a remote WCF DocumentServiceProxy (see SAIF.Services.ClientProxies) whose endpoint is resolved from the documentGeneratorServiceUrl environment setting. It renders and prints PDF packages, resolving the target printer from an explicit argument or, if none supplied, from the calling user's default printer via UserProfileService/Preferences, and selects the document profile (draft-watermarked vs. production) via DocumentHelper.
RestApiAppender	Class	SAIF.Services.Utilities.log4netAppenders	RestApiAppender extends log4net's AppenderSkeleton to ship rendered log events to a remote logging API over HTTP rather than to a file or console. It is the appender attached to the tracer built by LogService, and posts each logging event as a RestApiLogItem JSON payload on a background thread so logging calls do not block on the network request.
RestApiLogItem	Class	SAIF.Services.Utilities.log4netAppenders	RestApiLogItem is a plain data-transfer object representing a single rendered log event, serialized to JSON and POSTed by RestApiAppender to the remote logging API.
SaifUserProfile	Class	SAIF.Services.Utilities.UserProfile	SaifUserProfile implements ISaifUserProfile by extending ApplicationUserProfileBase<T> closed over WcfContracts.SaifUser. It represents an internal SAIF employee user, adding department, employee id, manager name/id, and job title fields on top of the base application-user contract. Instances are created only through its static factory methods, each resolving the underlying SaifUser via a different WCF SecurityServiceClient lookup (by user id or by employee id).
SecurityApiClient	Class	SAIF.Services.Utilities	SecurityApiClient implements ISecurityApiClient fronting the REST-based Security API — a distinct code path from the WCF SecurityServiceClient used elsewhere in this library (e.g. by SystemUserProfile). It validates that any supplied username is formatted domain\username before issuing a network call (BR-CORE-05, BR-CORE-12) and normalizes authorization role names to the environment-configured resource suffix (BR-CORE-06). For the full step-by-step trace, see the SecurityApiClient.GetUser / IsAuthorized operation page.
SystemUserProfile	Class	SAIF.Services.Utilities.UserProfile	SystemUserProfile implements ISystemUserProfile and is the root base class of the profile hierarchy — extended by ApplicationUserProfileBase<T> (and, in turn, ApplicationUserProfile, ExternalUserProfile, SaifUserProfile). Per its own XML-doc comment, it "exposes user security functions of the WCF security service client to framework callers." It owns the environment-scoped role-name authorization check (appending Test/Resource suffixes) and a static helper for retrieving typed WCF User contracts through a scoped SecurityServiceClient.
UC4Service	Class	SAIF.Services.Utilities	UC4Service implements IUC4Service and IDisposable, fronting a remote WCF UC4ServiceClient (see SAIF.Services.ClientProxies) whose endpoint is resolved from the uc4coreapi.url environment setting. It executes named jobs on the UC4 job-scheduling platform, optionally with a parameter dictionary, and returns a UC4Result per call.
UserProfileService	Class	SAIF.Services.Utilities.UserProfile	UserProfileService implements IUserProfileService and is the factory entry point for retrieving typed user-profile objects — ApplicationUserProfile, ExternalUserProfile, and SaifUserProfile — each constructed via that type's static GetByUserId/GetByEmployeeId/etc. factory using the shared IEnvironmentService and PreferenceService (IPreferenceService). The "current user" is resolved once, either from the constructor argument or from environmentService.UserId().
WorkCalendarService	Class	SAIF.Services.Utilities	WorkCalendarService implements IWorkCalendarService and IDisposable, fronting a remote WorkCalendarServiceProxy whose endpoint is resolved from the workCalendarServiceUrl environment setting (or, in the parameterless constructor, from a locally-constructed WindowsEnvironmentService). It answers business-day questions (first/last/next/previous work day of month, is-working-day) against a named calendar, translating the WorkCalendar enum to the remote service's calendar name via a fixed lookup (WorkCalendar.Saif → "SAIF").
DisposableClientBase\<TChannel>	Class	SAIF.Services.WCF.ClientProxies	DisposableClientBase<TChannel> is an abstract base class for generated/hand-written WCF client proxies (such as WCF32.ImagingServiceClient's sibling proxies elsewhere in the platform) that adds a safe IDisposable implementation on top of System.ServiceModel.ClientBase<TChannel>. It exists because closing a WCF channel that has faulted throws, so a naive using block around a raw ClientBase<TChannel> can mask the original service error with a secondary exception during disposal.
ErrorLogErrorHandler	Class	SAIF.Services.WCF.Common.Extensions	ErrorLogErrorHandler is a WCF System.ServiceModel.Dispatcher.IErrorHandler implementation that observes every unhandled exception raised while a service operation executes and logs it through the platform's OpenTelemetry-backed logging pipeline (LogService/OpenTelemetryExtensions). It is registered on a service host by LogErrorBehaviorAttribute, which attaches an instance of this handler to every channel dispatcher's ErrorHandlers collection.
IFaxService	Interface	SAIF.Services.WCF.Contracts	IFaxService is a WCF [ServiceContract(Name="FaxService")] interface that exposes fax transmission as a remote operation. It is the contract implemented by the platform's fax-service backend and consumed by callers that need to submit a fax job without hosting fax hardware/drivers themselves.
IFileService	Interface	SAIF.Services.WCF.Contracts	IFileService is a WCF [ServiceContract(Name="FileService")] interface exposing basic remote file I/O operations — partial and whole-file reads, writes, deletion, and length lookup — against files accessible to the hosting server. It lets callers manipulate server-side files (for example on an image or document share) without direct filesystem access.
IImagingService	Interface	SAIF.Services.WCF.Contracts	IImagingService (in SAIF.Services.WCF.Contracts) is a WCF [ServiceContract(Name = "Imaging")] interface for queuing document images for asynchronous processing into the imaging/document-management backend, and for pre-reserving image identifiers. A distinct, unrelated legacy contract of the same name exists in SAIF.Services.WCF.Imaging.WCF32 — see that page for the extraction-oriented contract.
IImagingService (SAIF.Services.WCF.Imaging.WCF32)	Interface	SAIF.Services.WCF.Imaging.WCF32	IImagingService in SAIF.Services.WCF.Imaging.WCF32 is a legacy WCF [ServiceContract(Name = "Imaging")] interface for extracting previously stored images by IFN disk set and numeric ID, and for computing image file-path/type information. It is distinct from — and unrelated in operation set to — SAIF.Services.WCF.Contracts.IImagingService, which queues new images for processing rather than extracting existing ones; the two types happen to share both a type name and a ServiceContract name (Imaging).
ImageOutput	Class	SAIF.Services.WCF.Imaging	ImageOutput is a plain data-transfer object returned by the legacy imaging extraction contract (WCF32.IImagingService.ExtractFile). It carries the extracted file's bytes and name alongside a success flag, a status message, and metadata describing how and where the extraction occurred, letting a caller distinguish a successful extraction (with usable file bytes) from a failed one (with a diagnostic Message).
ImagingHelper	Class	SAIF.Services.WCF.Imaging	ImagingHelper is a static helper class that centralizes IFN (imaged file number) disk-set and image-server path resolution logic shared by the platform's imaging services. It maps an ApplicationEnvironment plus a disk-set identifier to a physical image-server UNC path, converts between the numeric and string forms of the two known disk sets (production and development), and computes the sharded, base-256 relative directory structure used to store images by numeric ID.
ImagingServiceClient (SAIF.Services.WCF.Imaging.WCF32)	Class	SAIF.Services.WCF.Imaging.WCF32	ImagingServiceClient is the concrete WCF client proxy for the legacy WCF32.IImagingService contract. It extends System.ServiceModel.ClientBase<IImagingService> and implements IImagingService directly, configuring a BasicHttpBinding endpoint at a caller-supplied URL with the message-size limit raised to int.MaxValue so that large extracted image payloads are not rejected by the default WCF binding limits.
IPdfService	Interface	SAIF.Services.WCF.Contracts	IPdfService (declared in IPDFService.cs) is a WCF [ServiceContract(Name = "PDF")] interface exposing PDF processing operations — format conversion, merging/extracting multi-document PDFs, page counting, version/format inspection, and a health-check ping — consumed by document-generation callers in the platform.
IPreferenceService	Interface	SAIF.Services.WCF.Contracts	IPreferenceService is a WCF [ServiceContract(Name = "PreferenceService")] interface for storing and retrieving per-user, per-application/page UI preference key-value pairs, plus looking up a user's configured default printer. It extends System.IDisposable so client proxies implementing it can be released deterministically.
ISecurityService	Interface	SAIF.Services.WCF.Contracts	ISecurityService is a WCF [ServiceContract(Name="Security")] interface fronting the platform's centralized authorization and user-directory backend — role/resource authorization checks, internal and external user lookups by user ID/employee ID/customer ID, and Active Directory group-membership queries. It is the contract behind the SecurityServiceClient proxy referenced elsewhere in this library's authorization architecture.
IUC4Service	Interface	SAIF.Services.WCF.Contracts	IUC4Service is a WCF [ServiceContract(Name="UC4Service")] interface for triggering UC4 (job-scheduling/automation) jobs remotely. It provides eight ExecuteJob* overloads that vary along two independent axes: how the target environment is identified (an explicit UC4Environment versus a clientId) and how job parameters are supplied (none, positional string[] values, named key/value pairs, or a JSON-encoded object).
IWebContextService	Interface	SAIF.Services.WCF.Contracts	IWebContextService is a WCF [ServiceContract(Name = "WebContextService")] interface for creating, retrieving, and persisting a server-side IWebContext — a keyed bag of session-scoped values (claim ID, claim number, policy number, etc., as implemented by WebContext) — shared across an application's pages within a user session. It extends System.IDisposable so client proxies implementing it can be released deterministically.
LogErrorBehaviorAttribute	Class	SAIF.Services.WCF.Common.Extensions	LogErrorBehaviorAttribute is a WCF service-behavior attribute (System.ServiceModel.Description.IServiceBehavior) that, when applied to a service implementation class, wires an ErrorLogErrorHandler into every ChannelDispatcher of the hosting ServiceHostBase during dispatch-behavior application. Applying this attribute is the mechanism that activates automatic exception logging for a WCF service — ErrorLogErrorHandler alone has no effect until it is attached this way.
User	Class	SAIF.Services.WCF.Services.Security	User is a [Serializable] data-transfer object representing a directory/security-service user record — identity, domain, account-state flags, last-login timestamp, and an embedded Contact — returned by ISecurityService lookups such as GetUser. It is the base type for SaifUser (internal employee profile) and ExternalUser (external/injured-worker profile), both declared in the same source file.
WebContext	Class	SAIF.Services.WCF.Services	WebContext is the [Serializable] default implementation of IWebContext (declared in SAIF.Core.Contracts.WebContext) used by IWebContextService. It is a per-context bag of named string values — including well-known convenience accessors for claim ID, claim number, current value, policy number, and provider number — backed by an in-memory Dictionary<string, string>, allowing an application to store and share session-scoped values across pages.

Related documentation

• Index
• Overview
• Architecture
• Operations and processes
• Business rules

Sources

• Core\SAIF.Core\SAIF.Framework.Core.csproj
• All .cs source files referenced on the individual type pages linked above.