NAME

Data::Object::Config::Library

ABSTRACT

Data-Object Library Configuration

SYNOPSIS

  use Data::Object::Config::Library;

DESCRIPTION

Data::Object::Config::Library is a Type::Tiny type library that extends the Types::Standard, Types::Common::Numeric, and Types::Common::String libraries and adds type constraints and coercions for Data::Object objects.

TYPES

This package can export the following type constraints.

any

  has data => (
    is  => 'ro',
    isa => 'Any',
  );

The Any type constraint is provided by the Types::Standard library. Please see that documentation for more information. The assert_Any function can be used to throw an exception is the argument can not be validated. The is_Any function can be used to return true or false if the argument can not be validated.

anyobj

  has data => (
    is  => 'ro',
    isa => 'AnyObj',
  );

The AnyObj type constraint is provided by this library and accepts any object that is, or is derived from, a Data::Object::Any object. The assert_AnyObj function can be used to throw an exception if the argument can not be validated. The is_AnyObj function can be used to return true or false if the argument can not be validated.

anyobject

  has data => (
    is  => 'ro',
    isa => 'AnyObject',
  );

The AnyObject type constraint is provided by this library and accepts any object that is, or is derived from, a Data::Object::Any object. The assert_AnyObject function can be used to throw an exception if the argument can not be validated. The is_AnyObject function can be used to return true or false if the argument can not be validated.

arrayobj

  has data => (
    is  => 'ro',
    isa => 'ArrayObj',
  );

The ArrayObj type constraint is provided by this library and accepts any object that is, or is derived from, a Data::Object::Array object. The assert_ArrayObj function can be used to throw an exception if the argument can not be validated. The is_ArrayObj function can be used to return true or false if the argument can not be validated.

arrayobject

  has data => (
    is  => 'ro',
    isa => 'ArrayObject',
  );

The ArrayObject type constraint is provided by this library and accepts any object that is, or is derived from, a Data::Object::Array object. The assert_ArrayObject function can be used to throw an exception if the argument can not be validated. The is_ArrayObject function can be used to return true or false if the argument can not be validated.

arrayref

  has data => (
    is  => 'ro',
    isa => 'ArrayRef',
  );

The ArrayRef type constraint is provided by the Types::Standard library. Please see that documentation for more information. The assert_ArrayRef function can be used to throw an exception if the argument can not be validated. The is_ArrayRef function can be used to return true or false if the argument can not be validated.

bool

  has data => (
    is  => 'ro',
    isa => 'Bool',
  );

The Bool type constraint is provided by the Types::Standard library. Please see that documentation for more information. The assert_Bool function can be used to throw an exception if the argument can not be validated. The is_Bool function can be used to return true or false if the argument can not be validated.

classname

  has data => (
    is  => 'ro',
    isa => 'ClassName[MyClass]',
  );

The ClassName type constraint is provided by the Types::Standard library. Please see that documentation for more information. The assert_ClassName function can be used to throw an exception if the argument can not be validated. The is_ClassName function can be used to return true or false if the argument can not be validated.

codeobj

  has data => (
    is  => 'ro',
    isa => 'CodeObj',
  );

The CodeObj type constraint is provided by this library and accepts any object that is, or is derived from, a Data::Object::Code object. The assert_CodeObj function can be used to throw an exception if the argument can not be validated. The is_CodeObj function can be used to return true or false if the argument can not be validated.

codeobject

  has data => (
    is  => 'ro',
    isa => 'CodeObject',
  );

The CodeObject type constraint is provided by this library and accepts any object that is, or is derived from, a Data::Object::Code object. The assert_CodeObject function can be used to throw an exception if the argument can not be validated. The is_CodeObject function can be used to return true or false if the argument can not be validated.

coderef

  has data => (
    is  => 'ro',
    isa => 'CodeRef',
  );

The CodeRef type constraint is provided by the Types::Standard library. Please see that documentation for more information. The assert_CodeRef function can be used to throw an exception if the argument can not be validated. The is_CodeRef function can be used to return true or false if the argument can not be validated.

consumerof

  has data => (
    is  => 'ro',
    isa => 'ConsumerOf[MyRole]',
  );

The ConsumerOf type constraint is provided by the Types::Standard library. Please see that documentation for more information. The assert_ConsumerOf function can be used to throw an exception if the argument can not be validated. The is_ConsumerOf function can be used to return true or false if the argument can not be validated.

dataobj

  has data => (
    is  => 'ro',
    isa => 'DataObj',
  );

The DataObj type constraint is provided by this library and accepts any object that is, or is derived from, a Data::Object::Data object. The assert_DataObj function can be used to throw an exception if the argument can not be validated. The is_DataObj function can be used to return true or false if the argument can not be validated.

dataobject

  has data => (
    is  => 'ro',
    isa => 'DataObject',
  );

The DataObject type constraint is provided by this library and accepts any object that is, or is derived from, a Data::Object::Data object. The assert_DataObject function can be used to throw an exception if the argument can not be validated. The is_DataObject function can be used to return true or false if the argument can not be validated.

defined

  has data => (
    is  => 'ro',
    isa => 'Defined',
  );

The Defined type constraint is provided by the Types::Standard library. Please see that documentation for more information. The assert_Defined function can be used to throw an exception if the argument can not be validated. The is_Defined function can be used to return true or false if the argument can not be validated.

dict

  has data => (
    is  => 'ro',
    isa => 'Dict',
  );

The Dict type constraint is provided by the Types::Standard library. Please see that documentation for more information. The assert_Dict function can be used to throw an exception if the argument can not be validated. The is_Dict function can be used to return true or false if the argument can not be validated.

dispatchobj

  has data => (
    is  => 'ro',
    isa => 'DispatchObj',
  );

The DispatchObj type constraint is provided by this library and accepts any object that is, or is derived from, a Data::Object::Dispatch object. The assert_DispatchObj function can be used to throw an exception if the argument can not be validated. The is_DispatchObj function can be used to return true or false if the argument can not be validated.

dispatchobject

  has data => (
    is  => 'ro',
    isa => 'DispatchObject',
  );

The DispatchObject type constraint is provided by this library and accepts any object that is, or is derived from, a Data::Object::Dispatch object. The assert_DispatchObject function can be used to throw an exception if the argument can not be validated. The is_DispatchObject function can be used to return true or false if the argument can not be validated.

enum

  has data => (
    is  => 'ro',
    isa => 'Enum',
  );

The Enum type constraint is provided by the Types::Standard library. Please see that documentation for more information. The assert_Enum function can be used to throw an exception if the argument can not be validated. The is_Enum function can be used to return true or false if the argument can not be validated.

exceptionobj

  has data => (
    is  => 'ro',
    isa => 'ExceptionObj',
  );

The ExceptionObj type constraint is provided by this library and accepts any object that is, or is derived from, a Data::Object::Exception object. The assert_ExceptionObj function can be used to throw an exception if the argument can not be validated. The is_ExceptionObj function can be used to return true or false if the argument can not be validated.

exceptionobject

  has data => (
    is  => 'ro',
    isa => 'ExceptionObject',
  );

The ExceptionObject type constraint is provided by this library and accepts any object that is, or is derived from, a Data::Object::Exception object. The assert_ExceptionObject function can be used to throw an exception if the argument can not be validated. The is_ExceptionObject function can be used to return true or false if the argument can not be validated.

filehandle

  has data => (
    is  => 'ro',
    isa => 'FileHandle',
  );

The FileHandle type constraint is provided by the Types::Standard library. Please see that documentation for more information. The assert_FileHandle function can be used to throw an exception if the argument can not be validated. The is_FileHandle function can be used to return true or false if the argument can not be validated.

floatobj

  has data => (
    is  => 'ro',
    isa => 'FloatObj',
  );

The FloatObj type constraint is provided by this library and accepts any object that is, or is derived from, a Data::Object::Float object. The assert_FloatObj function can be used to throw an exception if the argument can not be validated. The is_FloatObj function can be used to return true or false if the argument can not be validated.

floatobject

  has data => (
    is  => 'ro',
    isa => 'FloatObject',
  );

The FloatObject type constraint is provided by this library and accepts any object that is, or is derived from, a Data::Object::Float object. The assert_FloatObject function can be used to throw an exception if the argument can not be validated. The is_FloatObject function can be used to return true or false if the argument can not be validated.

funcobj

  has data => (
    is  => 'ro',
    isa => 'FuncObj',
  );

The FuncObj type constraint is provided by this library and accepts any object that is, or is derived from, a Data::Object::Func object. The assert_FuncObj function can be used to throw an exception if the argument can not be validated. The is_FuncObj function can be used to return true or false if the argument can not be validated.

funcobject

  has data => (
    is  => 'ro',
    isa => 'FuncObject',
  );

The FuncObject type constraint is provided by this library and accepts any object that is, or is derived from, a Data::Object::Func object. The assert_FuncObject function can be used to throw an exception if the argument can not be validated. The is_FuncObject function can be used to return true or false if the argument can not be validated.

globref

  has data => (
    is  => 'ro',
    isa => 'GlobRef',
  );

The GlobRef type constraint is provided by the Types::Standard library. Please see that documentation for more information. The assert_GlobRef function can be used to throw an exception if the argument can not be validated. The is_GlobRef function can be used to return true or false if the argument can not be validated.

hasmethods

  has data => (
    is  => 'ro',
    isa => 'HasMethods[...]',
  );

The HasMethods type constraint is provided by the Types::Standard library. Please see that documentation for more information. The assert_HasMethods function can be used to throw an exception if the argument can not be validated. The is_HasMethods function can be used to return true or false if the argument can not be validated.

hashobj

  has data => (
    is  => 'ro',
    isa => 'HashObj',
  );

The HashObj type constraint is provided by this library and accepts any object that is, or is derived from, a Data::Object::Hash object. The assert_HashObj function can be used to throw an exception if the argument can not be validated. The is_HashObj function can be used to return true or false if the argument can not be validated.

hashobject

  has data => (
    is  => 'ro',
    isa => 'HashObject',
  );

The HashObject type constraint is provided by this library and accepts any object that is, or is derived from, a Data::Object::Hash object. The assert_HashObject function can be used to throw an exception if the argument can not be validated. The is_HashObject function can be used to return true or false if the argument can not be validated.

hashref

  has data => (
    is  => 'ro',
    isa => 'HashRef',
  );

The HashRef type constraint is provided by the Types::Standard library. Please see that documentation for more information. The assert_HashRef function can be used to throw an exception if the argument can not be validated. The is_HashRef function can be used to return true or false if the argument can not be validated.

instanceof

  has data => (
    is  => 'ro',
    isa => 'InstanceOf[MyClass]',
  );

The InstanceOf type constraint is provided by the Types::Standard library. Please see that documentation for more information. The assert_InstanceOf function can be used to throw an exception if the argument can not be validated. The is_InstanceOf function can be used to return true or false if the argument can not be validated.

int

  has data => (
    is  => 'ro',
    isa => 'Int',
  );

The Int type constraint is provided by the Types::Standard library. Please see that documentation for more information. The assert_Int function can be used to throw an exception if the argument can not be validated. The is_Int function can be used to return true or false if the argument can not be validated.

intobj

  has data => (
    is  => 'ro',
    isa => 'IntObj',
  );

The IntObj type constraint is provided by this library and accepts any object that is, or is derived from, a Data::Object::Integer object. The assert_IntObj function can be used to throw an exception if the argument can not be validated. The is_IntObj function can be used to return true or false if the argument can not be validated.

intobject

  has data => (
    is  => 'ro',
    isa => 'IntObject',
  );

The IntObject type constraint is provided by this library and accepts any object that is, or is derived from, a Data::Object::Integer object. The assert_IntObject function can be used to throw an exception if the argument can not be validated. The is_IntObject function can be used to return true or false if the argument can not be validated.

integerobj

  has data => (
    is  => 'ro',
    isa => 'IntegerObj',
  );

The IntegerObj type constraint is provided by this library and accepts any object that is, or is derived from, a Data::Object::Integer object. The assert_IntegerObj function can be used to throw an exception if the argument can not be validated. The is_IntegerObj function can be used to return true or false if the argument can not be validated.

integerobject

  has data => (
    is  => 'ro',
    isa => 'IntegerObject',
  );

The IntegerObject type constraint is provided by this library and accepts any object that is, or is derived from, a Data::Object::Integer object. The assert_IntegerObject function can be used to throw an exception if the argument can not be validated. The is_IntegerObject function can be used to return true or false if the argument can not be validated.

item

  has data => (
    is  => 'ro',
    isa => 'Item',
  );

The Item type constraint is provided by the Types::Standard library. Please see that documentation for more information. The assert_Item function can be used to throw an exception if the argument can not be validated. The is_Item function can be used to return true or false if the argument can not be validated.

jsonobj

  has data => (
    is  => 'ro',
    isa => 'JsonObj',
  );

The JsonObj type constraint is provided by this library and accepts any object that is, or is derived from, a Data::Object::Json object. The assert_JsonObj function can be used to throw an exception if the argument can not be validated. The is_JsonObj function can be used to return true or false if the argument can not be validated.

jsonobject

  has data => (
    is  => 'ro',
    isa => 'JsonObject',
  );

The JsonObject type constraint is provided by this library and accepts any object that is, or is derived from, a Data::Object::Json object. The assert_JsonObject function can be used to throw an exception if the argument can not be validated. The is_JsonObject function can be used to return true or false if the argument can not be validated.

laxnum

  has data => (
    is  => 'ro',
    isa => 'LaxNum',
  );

The LaxNum type constraint is provided by the Types::Standard library. Please see that documentation for more information. The assert_LaxNum function can be used to throw an exception if the argument can not be validated. The is_LaxNum function can be used to return true or false if the argument can not be validated.

lowercasesimplestr

  has data => (
    is  => 'ro',
    isa => 'LowerCaseSimpleStr',
  );

The LowerCaseSimpleStr type constraint is provided by the Types::Common::String library. Please see that documentation for more The assert_LowerCaseSimpleStr function can be used to throw an exception if the argument can not be validated. The is_LowerCaseSimpleStr function can be used to return true or false if the argument can not be validated. information.

lowercasestr

  has data => (
    is  => 'ro',
    isa => 'LowerCaseStr',
  );

The LowerCaseStr type constraint is provided by the Types::Common::String library. Please see that documentation for more information. The assert_type function can be used to throw an exception if the argument can not be validated. The is_type function can be used to return true or false if the argument can not be validated.

map

  has data => (
    is  => 'ro',
    isa => 'Map[Int', HashRef],
  );

The Map type constraint is provided by the Types::Standard library. Please see that documentation for more information. The assert_Map function can be used to throw an exception if the argument can not be validated. The is_Map function can be used to return true or false if the argument can not be validated.

maybe

  has data => (
    is  => 'ro',
    isa => 'Maybe',
  );

The Maybe type constraint is provided by the Types::Standard library. Please see that documentation for more information. The assert_Maybe function can be used to throw an exception if the argument can not be validated. The is_Maybe function can be used to return true or false if the argument can not be validated.

negativeint

  has data => (
    is  => 'ro',
    isa => 'NegativeInt',
  );

The NegativeInt type constraint is provided by the Types::Common::Numeric library. Please see that documentation for more information. The assert_NegativeInt function can be used to throw an exception if the argument can not be validated. The is_NegativeInt function can be used to return true or false if the argument can not be validated.

negativenum

  has data => (
    is  => 'ro',
    isa => 'NegativeNum',
  );

The NegativeNum type constraint is provided by the Types::Common::Numeric library. Please see that documentation for more information. The assert_NegativeNum function can be used to throw an exception if the argument can not be validated. The is_NegativeNum function can be used to return true or false if the argument can not be validated.

negativeorzeroint

  has data => (
    is  => 'ro',
    isa => 'NegativeOrZeroInt',
  );

The NegativeOrZeroInt type constraint is provided by the Types::Common::Numeric library. Please see that documentation for more The assert_NegativeOrZeroInt function can be used to throw an exception if the argument can not be validated. The is_NegativeOrZeroInt function can be used to return true or false if the argument can not be validated. information.

negativeorzeronum

  has data => (
    is  => 'ro',
    isa => 'NegativeOrZeroNum',
  );

The NegativeOrZeroNum type constraint is provided by the Types::Common::Numeric library. Please see that documentation for more The assert_type function can be used to throw an exception if the argument can not be validated. The is_type function can be used to return true or false if the argument can not be validated. information.

nonemptysimplestr

  has data => (
    is  => 'ro',
    isa => 'NonEmptySimpleStr',
  );

The NonEmptySimpleStr type constraint is provided by the Types::Common::String library. Please see that documentation for more The assert_type function can be used to throw an exception if the argument can not be validated. The is_type function can be used to return true or false if the argument can not be validated. information.

nonemptystr

  has data => (
    is  => 'ro',
    isa => 'NonEmptyStr',
  );

The NonEmptyStr type constraint is provided by the Types::Standard library. Please see that documentation for more information. The assert_type function can be used to throw an exception if the argument can not be validated. The is_type function can be used to return true or false if the argument can not be validated.

num

  has data => (
    is  => 'ro',
    isa => 'Num',
  );

The Num type constraint is provided by the Types::Standard library. Please see that documentation for more information. The assert_Num function can be used to throw an exception if the argument can not be validated. The is_Num function can be used to return true or false if the argument can not be validated.

numobj

  has data => (
    is  => 'ro',
    isa => 'NumObj',
  );

The NumObj type constraint is provided by this library and accepts any object that is, or is derived from, a Data::Object::Number object. The assert_NumObj function can be used to throw an exception if the argument can not be validated. The is_NumObj function can be used to return true or false if the argument can not be validated.

numobject

  has data => (
    is  => 'ro',
    isa => 'NumObject',
  );

The NumObject type constraint is provided by this library and accepts any object that is, or is derived from, a Data::Object::Number object. The assert_NumObject function can be used to throw an exception if the argument can not be validated. The is_NumObject function can be used to return true or false if the argument can not be validated.

numberobj

  has data => (
    is  => 'ro',
    isa => 'NumberObj',
  );

The NumberObj type constraint is provided by this library and accepts any object that is, or is derived from, a Data::Object::Number object. The assert_NumberObj function can be used to throw an exception if the argument can not be validated. The is_NumberObj function can be used to return true or false if the argument can not be validated.

numberobject

  has data => (
    is  => 'ro',
    isa => 'NumberObject',
  );

The NumberObject type constraint is provided by this library and accepts any object that is, or is derived from, a Data::Object::Number object. The assert_NumberObject function can be used to throw an exception if the argument can not be validated. The is_NumberObject function can be used to return true or false if the argument can not be validated.

numericcode

  has data => (
    is  => 'ro',
    isa => 'NumericCode',
  );

The NumericCode type constraint is provided by the Types::Common::String library. Please see that documentation for more information. The assert_NumericCode function can be used to throw an exception if the argument can not be validated. The is_NumericCode function can be used to return true or false if the argument can not be validated.

object

  has data => (
    is  => 'ro',
    isa => 'Object',
  );

The Object type constraint is provided by the Types::Standard library. Please see that documentation for more information. The assert_Object function can be used to throw an exception if the argument can not be validated. The is_Object function can be used to return true or false if the argument can not be validated.

optlist

  has data => (
    is  => 'ro',
    isa => 'OptList',
  );

The OptList type constraint is provided by the Types::Standard library. Please see that documentation for more information. The assert_OptList function can be used to throw an exception if the argument can not be validated. The is_OptList function can be used to return true or false if the argument can not be validated.

optional

  has data => (
    is  => 'ro',
    isa => 'Dict[id => Optional[Int]]',
  );

The Optional type constraint is provided by the Types::Standard library. Please see that documentation for more information. The assert_Optional function can be used to throw an exception if the argument can not be validated. The is_Optional function can be used to return true or false if the argument can not be validated.

overload

  has data => (
    is  => 'ro',
    isa => 'Overload',
  );

The Overload type constraint is provided by the Types::Standard library. Please see that documentation for more information. The assert_Overload function can be used to throw an exception if the argument can not be validated. The is_Overload function can be used to return true or false if the argument can not be validated.

password

  has data => (
    is  => 'ro',
    isa => 'Password',
  );

The Password type constraint is provided by the Types::Standard library. Please see that documentation for more information. The assert_Password function can be used to throw an exception if the argument can not be validated. The is_Password function can be used to return true or false if the argument can not be validated.

pathobj

  has data => (
    is  => 'ro',
    isa => 'PathObj',
  );

The PathObj type constraint is provided by this library and accepts any object that is, or is derived from, a Data::Object::Path object. The assert_PathObj function can be used to throw an exception if the argument can not be validated. The is_PathObj function can be used to return true or false if the argument can not be validated.

pathobject

  has data => (
    is  => 'ro',
    isa => 'PathObject',
  );

The PathObject type constraint is provided by this library and accepts any object that is, or is derived from, a Data::Object::Path object. The assert_PathObject function can be used to throw an exception if the argument can not be validated. The is_PathObject function can be used to return true or false if the argument can not be validated.

positiveint

  has data => (
    is  => 'ro',
    isa => 'PositiveInt',
  );

The PositiveInt type constraint is provided by the Types::Common::Numeric library. Please see that documentation for more information. The assert_PositiveInt function can be used to throw an exception if the argument can not be validated. The is_PositiveInt function can be used to return true or false if the argument can not be validated.

positivenum

  has data => (
    is  => 'ro',
    isa => 'PositiveNum',
  );

The PositiveNum type constraint is provided by the Types::Common::Numeric library. Please see that documentation for more information. The assert_PositiveNum function can be used to throw an exception if the argument can not be validated. The is_PositiveNum function can be used to return true or false if the argument can not be validated.

positiveorzeroint

  has data => (
    is  => 'ro',
    isa => 'PositiveOrZeroInt',
  );

The PositiveOrZeroInt type constraint is provided by the Types::Common::Numeric library. Please see that documentation for more The assert_PositiveOrZeroInt function can be used to throw an exception if the argument can not be validated. The is_PositiveOrZeroInt function can be used to return true or false if the argument can not be validated. information.

positiveorzeronum

  has data => (
    is  => 'ro',
    isa => 'PositiveOrZeroNum',
  );

The PositiveOrZeroNum type constraint is provided by the Types::Common::Numeric library. Please see that documentation for more The assert_type function can be used to throw an exception if the argument can not be validated. The is_type function can be used to return true or false if the argument can not be validated. information.

ref

  has data => (
    is  => 'ro',
    isa => 'Ref[SCALAR]',
  );

The Ref type constraint is provided by the Types::Standard library. Please see that documentation for more information. The assert_type function can be used to throw an exception if the argument can not be validated. The is_type function can be used to return true or false if the argument can not be validated.

regexpobj

  has data => (
    is  => 'ro',
    isa => 'RegexpObj',
  );

The RegexpObj type constraint is provided by this library and accepts any object that is, or is derived from, a Data::Object::Regexp object. The assert_RegexpObj function can be used to throw an exception if the argument can not be validated. The is_RegexpObj function can be used to return true or false if the argument can not be validated.

regexpobject

  has data => (
    is  => 'ro',
    isa => 'RegexpObject',
  );

The RegexpObject type constraint is provided by this library and accepts any object that is, or is derived from, a Data::Object::Regexp object. The assert_RegexpObject function can be used to throw an exception if the argument can not be validated. The is_RegexpObject function can be used to return true or false if the argument can not be validated.

regexpref

  has data => (
    is  => 'ro',
    isa => 'RegexpRef',
  );

The RegexpRef type constraint is provided by the Types::Standard library. Please see that documentation for more information. The assert_RegexpRef function can be used to throw an exception if the argument can not be validated. The is_RegexpRef function can be used to return true or false if the argument can not be validated.

replaceobj

  has data => (
    is  => 'ro',
    isa => 'ReplaceObj',
  );

The ReplaceObj type constraint is provided by this library and accepts any object that is, or is derived from, a Data::Object::Replace object. The assert_ReplaceObj function can be used to throw an exception if the argument can not be validated. The is_ReplaceObj function can be used to return true or false if the argument can not be validated.

replaceobject

  has data => (
    is  => 'ro',
    isa => 'ReplaceObject',
  );

The ReplaceObject type constraint is provided by this library and accepts any object that is, or is derived from, a Data::Object::Replace object. The assert_ReplaceObject function can be used to throw an exception if the argument can not be validated. The is_ReplaceObject function can be used to return true or false if the argument can not be validated.

rolename

  has data => (
    is  => 'ro',
    isa => 'RoleName',
  );

The RoleName type constraint is provided by the Types::Standard library. Please see that documentation for more information. The assert_RoleName function can be used to throw an exception if the argument can not be validated. The is_RoleName function can be used to return true or false if the argument can not be validated.

scalarobj

  has data => (
    is  => 'ro',
    isa => 'ScalarObj',
  );

The ScalarObj type constraint is provided by this library and accepts any object that is, or is derived from, a Data::Object::Scalar object. The assert_ScalarObj function can be used to throw an exception if the argument can not be validated. The is_ScalarObj function can be used to return true or false if the argument can not be validated.

scalarobject

  has data => (
    is  => 'ro',
    isa => 'ScalarObject',
  );

The ScalarObject type constraint is provided by this library and accepts any object that is, or is derived from, a Data::Object::Scalar object. The assert_ScalarObject function can be used to throw an exception if the argument can not be validated. The is_ScalarObject function can be used to return true or false if the argument can not be validated.

scalarref

  has data => (
    is  => 'ro',
    isa => 'ScalarRef',
  );

The ScalarRef type constraint is provided by the Types::Standard library. Please see that documentation for more information. The assert_ScalarRef function can be used to throw an exception if the argument can not be validated. The is_ScalarRef function can be used to return true or false if the argument can not be validated.

searchobj

  has data => (
    is  => 'ro',
    isa => 'SearchObj',
  );

The SearchObj type constraint is provided by this library and accepts any object that is, or is derived from, a Data::Object::Search object. The assert_SearchObj function can be used to throw an exception if the argument can not be validated. The is_SearchObj function can be used to return true or false if the argument can not be validated.

searchobject

  has data => (
    is  => 'ro',
    isa => 'SearchObject',
  );

The SearchObject type constraint is provided by this library and accepts any object that is, or is derived from, a Data::Object::Search object. The assert_SearchObject function can be used to throw an exception if the argument can not be validated. The is_SearchObject function can be used to return true or false if the argument can not be validated.

simplestr

  has data => (
    is  => 'ro',
    isa => 'SimpleStr',
  );

The SimpleStr type constraint is provided by the Types::Common::String library. Please see that documentation for more information. The assert_SimpleStr function can be used to throw an exception if the argument can not be validated. The is_SimpleStr function can be used to return true or false if the argument can not be validated.

singledigit

  has data => (
    is  => 'ro',
    isa => 'SingleDigit',
  );

The SingleDigit type constraint is provided by the Types::Common::Numeric library. Please see that documentation for more information. The assert_SingleDigit function can be used to throw an exception if the argument can not be validated. The is_SingleDigit function can be used to return true or false if the argument can not be validated.

spaceobj

  has data => (
    is  => 'ro',
    isa => 'SpaceObj',
  );

The SpaceObj type constraint is provided by this library and accepts any object that is, or is derived from, a Data::Object::Space object. The assert_SpaceObj function can be used to throw an exception if the argument can not be validated. The is_SpaceObj function can be used to return true or false if the argument can not be validated.

spaceobject

  has data => (
    is  => 'ro',
    isa => 'SpaceObject',
  );

The SpaceObject type constraint is provided by this library and accepts any object that is, or is derived from, a Data::Object::Space object. The assert_SpaceObject function can be used to throw an exception if the argument can not be validated. The is_SpaceObject function can be used to return true or false if the argument can not be validated.

str

  has data => (
    is  => 'ro',
    isa => 'Str',
  );

The Str type constraint is provided by the Types::Standard library. Please see that documentation for more information. The assert_Str function can be used to throw an exception if the argument can not be validated. The is_Str function can be used to return true or false if the argument can not be validated.

strmatch

  has data => (
    is  => 'ro',
    isa => 'StrMatch',
  );

The StrMatch type constraint is provided by the Types::Standard library. Please see that documentation for more information. The assert_StrMatch function can be used to throw an exception if the argument can not be validated. The is_StrMatch function can be used to return true or false if the argument can not be validated.

strobj

  has data => (
    is  => 'ro',
    isa => 'StrObj',
  );

The StrObj type constraint is provided by this library and accepts any object that is, or is derived from, a Data::Object::String object. The assert_StrObj function can be used to throw an exception if the argument can not be validated. The is_StrObj function can be used to return true or false if the argument can not be validated.

strobject

  has data => (
    is  => 'ro',
    isa => 'StrObject',
  );

The StrObject type constraint is provided by this library and accepts any object that is, or is derived from, a Data::Object::String object. The assert_StrObject function can be used to throw an exception if the argument can not be validated. The is_StrObject function can be used to return true or false if the argument can not be validated.

strictnum

  has data => (
    is  => 'ro',
    isa => 'StrictNum',
  );

The StrictNum type constraint is provided by the Types::Standard library. Please see that documentation for more information. The assert_StrictNum function can be used to throw an exception if the argument can not be validated. The is_StrictNum function can be used to return true or false if the argument can not be validated.

stringobj

  has data => (
    is  => 'ro',
    isa => 'StringObj',
  );

The StringObj type constraint is provided by this library and accepts any object that is, or is derived from, a Data::Object::String object. The assert_StringObj function can be used to throw an exception if the argument can not be validated. The is_StringObj function can be used to return true or false if the argument can not be validated.

stringobject

  has data => (
    is  => 'ro',
    isa => 'StringObject',
  );

The StringObject type constraint is provided by this library and accepts any object that is, or is derived from, a Data::Object::String object. The assert_StringObject function can be used to throw an exception if the argument can not be validated. The is_StringObject function can be used to return true or false if the argument can not be validated.

strongpassword

  has data => (
    is  => 'ro',
    isa => 'StrongPassword',
  );

The StrongPassword type constraint is provided by the Types::Common::String library. Please see that documentation for more information. The assert_StrongPassword function can be used to throw an exception if the argument can not be validated. The is_StrongPassword function can be used to return true or false if the argument can not be validated.

templateobj

  has data => (
    is  => 'ro',
    isa => 'TemplateObj',
  );

The TemplateObj type constraint is provided by this library and accepts any object that is, or is derived from, a Data::Object::Template object. The assert_TemplateObj function can be used to throw an exception if the argument can not be validated. The is_TemplateObj function can be used to return true or false if the argument can not be validated.

templateobject

  has data => (
    is  => 'ro',
    isa => 'TemplateObject',
  );

The TemplateObject type constraint is provided by this library and accepts any object that is, or is derived from, a Data::Object::Template object. The assert_TemplateObject function can be used to throw an exception if the argument can not be validated. The is_TemplateObject function can be used to return true or false if the argument can not be validated.

tied

  has data => (
    is  => 'ro',
    isa => 'Tied[MyClass]',
  );

The Tied type constraint is provided by the Types::Standard library. Please see that documentation for more information. The assert_Tied function can be used to throw an exception if the argument can not be validated. The is_Tied function can be used to return true or false if the argument can not be validated.

tuple

  has data => (
    is  => 'ro',
    isa => 'Tuple[Int, Str, Str],
  );

The Tuple type constraint is provided by the Types::Standard library. Please see that documentation for more information. The assert_Tuple function can be used to throw an exception if the argument can not be validated. The is_Tuple function can be used to return true or false if the argument can not be validated.

undef

  has data => (
    is  => 'ro',
    isa => 'Undef',
  );

The Undef type constraint is provided by the Types::Standard library. Please see that documentation for more information. The assert_Undef function can be used to throw an exception if the argument can not be validated. The is_Undef function can be used to return true or false if the argument can not be validated.

undefobj

  has data => (
    is  => 'ro',
    isa => 'UndefObj',
  );

The UndefObj type constraint is provided by this library and accepts any object that is, or is derived from, a Data::Object::Undef object. The assert_UndefObj function can be used to throw an exception if the argument can not be validated. The is_UndefObj function can be used to return true or false if the argument can not be validated.

undefobject

  has data => (
    is  => 'ro',
    isa => 'UndefObject',
  );

The UndefObject type constraint is provided by this library and accepts any object that is, or is derived from, a Data::Object::Undef object. The assert_UndefObject function can be used to throw an exception if the argument can not be validated. The is_UndefObject function can be used to return true or false if the argument can not be validated.

uppercasesimplestr

  has data => (
    is  => 'ro',
    isa => 'UpperCaseSimpleStr',
  );

The UpperCaseSimpleStr type constraint is provided by the Types::Common::String library. Please see that documentation for more The assert_UpperCaseSimpleStr function can be used to throw an exception if the argument can not be validated. The is_UpperCaseSimpleStr function can be used to return true or false if the argument can not be validated. information.

uppercasestr

  has data => (
    is  => 'ro',
    isa => 'UpperCaseStr',
  );

The UpperCaseStr type constraint is provided by the Types::Common::String library. Please see that documentation for more information. The assert_type function can be used to throw an exception if the argument can not be validated. The is_type function can be used to return true or false if the argument can not be validated.

value

  has data => (
    is  => 'ro',
    isa => 'Value',
  );

The Value type constraint is provided by the Types::Standard library. Please see that documentation for more information. The assert_Value function can be used to throw an exception if the argument can not be validated. The is_Value function can be used to return true or false if the argument can not be validated.

yamlobj

  has data => (
    is  => 'ro',
    isa => 'YamlObj',
  );

The YamlObj type constraint is provided by this library and accepts any object that is, or is derived from, a Data::Object::Yaml object. The assert_YamlObj function can be used to throw an exception if the argument can not be validated. The is_YamlObj function can be used to return true or false if the argument can not be validated.

yamlobject

  has data => (
    is  => 'ro',
    isa => 'YamlObject',
  );

The YamlObject type constraint is provided by this library and accepts any object that is, or is derived from, a Data::Object::Yaml object. The assert_YamlObject function can be used to throw an exception if the argument can not be validated. The is_YamlObject function can be used to return true or false if the argument can not be validated.