# This file was created automatically by SWIG 1.3.29.
# Don't modify this file, modify the SWIG interface instead.
package LibStorage;
require Exporter;
require DynaLoader;
@ISA = qw(Exporter DynaLoader);
package LibStoragec;
bootstrap LibStorage;
package LibStorage;
@EXPORT = qw( );

# ---------- BASE METHODS -------------

package LibStorage;

sub TIEHASH {
    my ($classname,$obj) = @_;
    return bless $obj, $classname;
}

sub CLEAR { }

sub FIRSTKEY { }

sub NEXTKEY { }

sub FETCH {
    my ($self,$field) = @_;
    my $member_func = "swig_${field}_get";
    $self->$member_func();
}

sub STORE {
    my ($self,$field,$newval) = @_;
    my $member_func = "swig_${field}_set";
    $self->$member_func($newval);
}

sub this {
    my $ptr = shift;
    return tied(%$ptr);
}


# ------- FUNCTION WRAPPERS --------

package LibStorage;

*initDefaultLogger = *LibStoragec::initDefaultLogger;
*createDefaultStorageInterface = *LibStoragec::createDefaultStorageInterface;
*createStorageInterface = *LibStoragec::createStorageInterface;
*destroyStorageInterface = *LibStoragec::destroyStorageInterface;

############# Class : LibStorage::FsCapabilities ##############

package LibStorage::FsCapabilities;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( LibStorage );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = LibStoragec::new_FsCapabilities(@_);
    bless $self, $pkg if defined($self);
}

*swig_isExtendable_get = *LibStoragec::FsCapabilities_isExtendable_get;
*swig_isExtendable_set = *LibStoragec::FsCapabilities_isExtendable_set;
*swig_isExtendableWhileMounted_get = *LibStoragec::FsCapabilities_isExtendableWhileMounted_get;
*swig_isExtendableWhileMounted_set = *LibStoragec::FsCapabilities_isExtendableWhileMounted_set;
*swig_isReduceable_get = *LibStoragec::FsCapabilities_isReduceable_get;
*swig_isReduceable_set = *LibStoragec::FsCapabilities_isReduceable_set;
*swig_isReduceableWhileMounted_get = *LibStoragec::FsCapabilities_isReduceableWhileMounted_get;
*swig_isReduceableWhileMounted_set = *LibStoragec::FsCapabilities_isReduceableWhileMounted_set;
*swig_supportsUuid_get = *LibStoragec::FsCapabilities_supportsUuid_get;
*swig_supportsUuid_set = *LibStoragec::FsCapabilities_supportsUuid_set;
*swig_supportsLabel_get = *LibStoragec::FsCapabilities_supportsLabel_get;
*swig_supportsLabel_set = *LibStoragec::FsCapabilities_supportsLabel_set;
*swig_labelWhileMounted_get = *LibStoragec::FsCapabilities_labelWhileMounted_get;
*swig_labelWhileMounted_set = *LibStoragec::FsCapabilities_labelWhileMounted_set;
*swig_labelLength_get = *LibStoragec::FsCapabilities_labelLength_get;
*swig_labelLength_set = *LibStoragec::FsCapabilities_labelLength_set;
*swig_minimalFsSizeK_get = *LibStoragec::FsCapabilities_minimalFsSizeK_get;
*swig_minimalFsSizeK_set = *LibStoragec::FsCapabilities_minimalFsSizeK_set;
sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        LibStoragec::delete_FsCapabilities($self);
        delete $OWNER{$self};
    }
}

sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : LibStorage::ContainerInfo ##############

package LibStorage::ContainerInfo;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( LibStorage );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = LibStoragec::new_ContainerInfo(@_);
    bless $self, $pkg if defined($self);
}

*swig_type_get = *LibStoragec::ContainerInfo_type_get;
*swig_type_set = *LibStoragec::ContainerInfo_type_set;
*swig_volcnt_get = *LibStoragec::ContainerInfo_volcnt_get;
*swig_volcnt_set = *LibStoragec::ContainerInfo_volcnt_set;
*swig_device_get = *LibStoragec::ContainerInfo_device_get;
*swig_device_set = *LibStoragec::ContainerInfo_device_set;
*swig_name_get = *LibStoragec::ContainerInfo_name_get;
*swig_name_set = *LibStoragec::ContainerInfo_name_set;
*swig_usedBy_get = *LibStoragec::ContainerInfo_usedBy_get;
*swig_usedBy_set = *LibStoragec::ContainerInfo_usedBy_set;
*swig_usedByName_get = *LibStoragec::ContainerInfo_usedByName_get;
*swig_usedByName_set = *LibStoragec::ContainerInfo_usedByName_set;
*swig_readonly_get = *LibStoragec::ContainerInfo_readonly_get;
*swig_readonly_set = *LibStoragec::ContainerInfo_readonly_set;
sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        LibStoragec::delete_ContainerInfo($self);
        delete $OWNER{$self};
    }
}

sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : LibStorage::DiskInfo ##############

package LibStorage::DiskInfo;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( LibStorage );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = LibStoragec::new_DiskInfo(@_);
    bless $self, $pkg if defined($self);
}

*swig_sizeK_get = *LibStoragec::DiskInfo_sizeK_get;
*swig_sizeK_set = *LibStoragec::DiskInfo_sizeK_set;
*swig_cylSizeB_get = *LibStoragec::DiskInfo_cylSizeB_get;
*swig_cylSizeB_set = *LibStoragec::DiskInfo_cylSizeB_set;
*swig_cyl_get = *LibStoragec::DiskInfo_cyl_get;
*swig_cyl_set = *LibStoragec::DiskInfo_cyl_set;
*swig_heads_get = *LibStoragec::DiskInfo_heads_get;
*swig_heads_set = *LibStoragec::DiskInfo_heads_set;
*swig_sectors_get = *LibStoragec::DiskInfo_sectors_get;
*swig_sectors_set = *LibStoragec::DiskInfo_sectors_set;
*swig_disklabel_get = *LibStoragec::DiskInfo_disklabel_get;
*swig_disklabel_set = *LibStoragec::DiskInfo_disklabel_set;
*swig_udevPath_get = *LibStoragec::DiskInfo_udevPath_get;
*swig_udevPath_set = *LibStoragec::DiskInfo_udevPath_set;
*swig_udevId_get = *LibStoragec::DiskInfo_udevId_get;
*swig_udevId_set = *LibStoragec::DiskInfo_udevId_set;
*swig_maxLogical_get = *LibStoragec::DiskInfo_maxLogical_get;
*swig_maxLogical_set = *LibStoragec::DiskInfo_maxLogical_set;
*swig_maxPrimary_get = *LibStoragec::DiskInfo_maxPrimary_get;
*swig_maxPrimary_set = *LibStoragec::DiskInfo_maxPrimary_set;
*swig_initDisk_get = *LibStoragec::DiskInfo_initDisk_get;
*swig_initDisk_set = *LibStoragec::DiskInfo_initDisk_set;
sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        LibStoragec::delete_DiskInfo($self);
        delete $OWNER{$self};
    }
}

sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : LibStorage::LvmVgInfo ##############

package LibStorage::LvmVgInfo;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( LibStorage );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = LibStoragec::new_LvmVgInfo(@_);
    bless $self, $pkg if defined($self);
}

*swig_sizeK_get = *LibStoragec::LvmVgInfo_sizeK_get;
*swig_sizeK_set = *LibStoragec::LvmVgInfo_sizeK_set;
*swig_peSize_get = *LibStoragec::LvmVgInfo_peSize_get;
*swig_peSize_set = *LibStoragec::LvmVgInfo_peSize_set;
*swig_peCount_get = *LibStoragec::LvmVgInfo_peCount_get;
*swig_peCount_set = *LibStoragec::LvmVgInfo_peCount_set;
*swig_peFree_get = *LibStoragec::LvmVgInfo_peFree_get;
*swig_peFree_set = *LibStoragec::LvmVgInfo_peFree_set;
*swig_uuid_get = *LibStoragec::LvmVgInfo_uuid_get;
*swig_uuid_set = *LibStoragec::LvmVgInfo_uuid_set;
*swig_lvm2_get = *LibStoragec::LvmVgInfo_lvm2_get;
*swig_lvm2_set = *LibStoragec::LvmVgInfo_lvm2_set;
*swig_create_get = *LibStoragec::LvmVgInfo_create_get;
*swig_create_set = *LibStoragec::LvmVgInfo_create_set;
*swig_devices_get = *LibStoragec::LvmVgInfo_devices_get;
*swig_devices_set = *LibStoragec::LvmVgInfo_devices_set;
*swig_devices_add_get = *LibStoragec::LvmVgInfo_devices_add_get;
*swig_devices_add_set = *LibStoragec::LvmVgInfo_devices_add_set;
*swig_devices_rem_get = *LibStoragec::LvmVgInfo_devices_rem_get;
*swig_devices_rem_set = *LibStoragec::LvmVgInfo_devices_rem_set;
sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        LibStoragec::delete_LvmVgInfo($self);
        delete $OWNER{$self};
    }
}

sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : LibStorage::EvmsCoInfo ##############

package LibStorage::EvmsCoInfo;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( LibStorage );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = LibStoragec::new_EvmsCoInfo(@_);
    bless $self, $pkg if defined($self);
}

*swig_sizeK_get = *LibStoragec::EvmsCoInfo_sizeK_get;
*swig_sizeK_set = *LibStoragec::EvmsCoInfo_sizeK_set;
*swig_peSize_get = *LibStoragec::EvmsCoInfo_peSize_get;
*swig_peSize_set = *LibStoragec::EvmsCoInfo_peSize_set;
*swig_peCount_get = *LibStoragec::EvmsCoInfo_peCount_get;
*swig_peCount_set = *LibStoragec::EvmsCoInfo_peCount_set;
*swig_peFree_get = *LibStoragec::EvmsCoInfo_peFree_get;
*swig_peFree_set = *LibStoragec::EvmsCoInfo_peFree_set;
*swig_uuid_get = *LibStoragec::EvmsCoInfo_uuid_get;
*swig_uuid_set = *LibStoragec::EvmsCoInfo_uuid_set;
*swig_lvm2_get = *LibStoragec::EvmsCoInfo_lvm2_get;
*swig_lvm2_set = *LibStoragec::EvmsCoInfo_lvm2_set;
*swig_create_get = *LibStoragec::EvmsCoInfo_create_get;
*swig_create_set = *LibStoragec::EvmsCoInfo_create_set;
*swig_realContainer_get = *LibStoragec::EvmsCoInfo_realContainer_get;
*swig_realContainer_set = *LibStoragec::EvmsCoInfo_realContainer_set;
*swig_devices_get = *LibStoragec::EvmsCoInfo_devices_get;
*swig_devices_set = *LibStoragec::EvmsCoInfo_devices_set;
*swig_devices_add_get = *LibStoragec::EvmsCoInfo_devices_add_get;
*swig_devices_add_set = *LibStoragec::EvmsCoInfo_devices_add_set;
*swig_devices_rem_get = *LibStoragec::EvmsCoInfo_devices_rem_get;
*swig_devices_rem_set = *LibStoragec::EvmsCoInfo_devices_rem_set;
sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        LibStoragec::delete_EvmsCoInfo($self);
        delete $OWNER{$self};
    }
}

sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : LibStorage::DmPartCoInfo ##############

package LibStorage::DmPartCoInfo;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( LibStorage );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = LibStoragec::new_DmPartCoInfo(@_);
    bless $self, $pkg if defined($self);
}

*swig_d_get = *LibStoragec::DmPartCoInfo_d_get;
*swig_d_set = *LibStoragec::DmPartCoInfo_d_set;
*swig_devices_get = *LibStoragec::DmPartCoInfo_devices_get;
*swig_devices_set = *LibStoragec::DmPartCoInfo_devices_set;
sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        LibStoragec::delete_DmPartCoInfo($self);
        delete $OWNER{$self};
    }
}

sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : LibStorage::DmraidCoInfo ##############

package LibStorage::DmraidCoInfo;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( LibStorage );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = LibStoragec::new_DmraidCoInfo(@_);
    bless $self, $pkg if defined($self);
}

*swig_p_get = *LibStoragec::DmraidCoInfo_p_get;
*swig_p_set = *LibStoragec::DmraidCoInfo_p_set;
sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        LibStoragec::delete_DmraidCoInfo($self);
        delete $OWNER{$self};
    }
}

sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : LibStorage::VolumeInfo ##############

package LibStorage::VolumeInfo;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( LibStorage );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = LibStoragec::new_VolumeInfo(@_);
    bless $self, $pkg if defined($self);
}

*swig_sizeK_get = *LibStoragec::VolumeInfo_sizeK_get;
*swig_sizeK_set = *LibStoragec::VolumeInfo_sizeK_set;
*swig_major_get = *LibStoragec::VolumeInfo_major_get;
*swig_major_set = *LibStoragec::VolumeInfo_major_set;
*swig_minor_get = *LibStoragec::VolumeInfo_minor_get;
*swig_minor_set = *LibStoragec::VolumeInfo_minor_set;
*swig_name_get = *LibStoragec::VolumeInfo_name_get;
*swig_name_set = *LibStoragec::VolumeInfo_name_set;
*swig_device_get = *LibStoragec::VolumeInfo_device_get;
*swig_device_set = *LibStoragec::VolumeInfo_device_set;
*swig_mount_get = *LibStoragec::VolumeInfo_mount_get;
*swig_mount_set = *LibStoragec::VolumeInfo_mount_set;
*swig_mount_by_get = *LibStoragec::VolumeInfo_mount_by_get;
*swig_mount_by_set = *LibStoragec::VolumeInfo_mount_by_set;
*swig_usedBy_get = *LibStoragec::VolumeInfo_usedBy_get;
*swig_usedBy_set = *LibStoragec::VolumeInfo_usedBy_set;
*swig_usedByName_get = *LibStoragec::VolumeInfo_usedByName_get;
*swig_usedByName_set = *LibStoragec::VolumeInfo_usedByName_set;
*swig_fstab_options_get = *LibStoragec::VolumeInfo_fstab_options_get;
*swig_fstab_options_set = *LibStoragec::VolumeInfo_fstab_options_set;
*swig_uuid_get = *LibStoragec::VolumeInfo_uuid_get;
*swig_uuid_set = *LibStoragec::VolumeInfo_uuid_set;
*swig_label_get = *LibStoragec::VolumeInfo_label_get;
*swig_label_set = *LibStoragec::VolumeInfo_label_set;
*swig_mkfs_options_get = *LibStoragec::VolumeInfo_mkfs_options_get;
*swig_mkfs_options_set = *LibStoragec::VolumeInfo_mkfs_options_set;
*swig_loop_get = *LibStoragec::VolumeInfo_loop_get;
*swig_loop_set = *LibStoragec::VolumeInfo_loop_set;
*swig_dtxt_get = *LibStoragec::VolumeInfo_dtxt_get;
*swig_dtxt_set = *LibStoragec::VolumeInfo_dtxt_set;
*swig_encryption_get = *LibStoragec::VolumeInfo_encryption_get;
*swig_encryption_set = *LibStoragec::VolumeInfo_encryption_set;
*swig_crypt_pwd_get = *LibStoragec::VolumeInfo_crypt_pwd_get;
*swig_crypt_pwd_set = *LibStoragec::VolumeInfo_crypt_pwd_set;
*swig_fs_get = *LibStoragec::VolumeInfo_fs_get;
*swig_fs_set = *LibStoragec::VolumeInfo_fs_set;
*swig_format_get = *LibStoragec::VolumeInfo_format_get;
*swig_format_set = *LibStoragec::VolumeInfo_format_set;
*swig_create_get = *LibStoragec::VolumeInfo_create_get;
*swig_create_set = *LibStoragec::VolumeInfo_create_set;
*swig_is_mounted_get = *LibStoragec::VolumeInfo_is_mounted_get;
*swig_is_mounted_set = *LibStoragec::VolumeInfo_is_mounted_set;
*swig_resize_get = *LibStoragec::VolumeInfo_resize_get;
*swig_resize_set = *LibStoragec::VolumeInfo_resize_set;
*swig_ignore_fs_get = *LibStoragec::VolumeInfo_ignore_fs_get;
*swig_ignore_fs_set = *LibStoragec::VolumeInfo_ignore_fs_set;
*swig_OrigSizeK_get = *LibStoragec::VolumeInfo_OrigSizeK_get;
*swig_OrigSizeK_set = *LibStoragec::VolumeInfo_OrigSizeK_set;
sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        LibStoragec::delete_VolumeInfo($self);
        delete $OWNER{$self};
    }
}

sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : LibStorage::PartitionAddInfo ##############

package LibStorage::PartitionAddInfo;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( LibStorage );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = LibStoragec::new_PartitionAddInfo(@_);
    bless $self, $pkg if defined($self);
}

*swig_nr_get = *LibStoragec::PartitionAddInfo_nr_get;
*swig_nr_set = *LibStoragec::PartitionAddInfo_nr_set;
*swig_cylStart_get = *LibStoragec::PartitionAddInfo_cylStart_get;
*swig_cylStart_set = *LibStoragec::PartitionAddInfo_cylStart_set;
*swig_cylSize_get = *LibStoragec::PartitionAddInfo_cylSize_get;
*swig_cylSize_set = *LibStoragec::PartitionAddInfo_cylSize_set;
*swig_partitionType_get = *LibStoragec::PartitionAddInfo_partitionType_get;
*swig_partitionType_set = *LibStoragec::PartitionAddInfo_partitionType_set;
*swig_id_get = *LibStoragec::PartitionAddInfo_id_get;
*swig_id_set = *LibStoragec::PartitionAddInfo_id_set;
*swig_boot_get = *LibStoragec::PartitionAddInfo_boot_get;
*swig_boot_set = *LibStoragec::PartitionAddInfo_boot_set;
*swig_udevPath_get = *LibStoragec::PartitionAddInfo_udevPath_get;
*swig_udevPath_set = *LibStoragec::PartitionAddInfo_udevPath_set;
*swig_udevId_get = *LibStoragec::PartitionAddInfo_udevId_get;
*swig_udevId_set = *LibStoragec::PartitionAddInfo_udevId_set;
sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        LibStoragec::delete_PartitionAddInfo($self);
        delete $OWNER{$self};
    }
}

sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : LibStorage::PartitionInfo ##############

package LibStorage::PartitionInfo;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( LibStorage );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = LibStoragec::new_PartitionInfo(@_);
    bless $self, $pkg if defined($self);
}

*swig_v_get = *LibStoragec::PartitionInfo_v_get;
*swig_v_set = *LibStoragec::PartitionInfo_v_set;
*swig_nr_get = *LibStoragec::PartitionInfo_nr_get;
*swig_nr_set = *LibStoragec::PartitionInfo_nr_set;
*swig_cylStart_get = *LibStoragec::PartitionInfo_cylStart_get;
*swig_cylStart_set = *LibStoragec::PartitionInfo_cylStart_set;
*swig_cylSize_get = *LibStoragec::PartitionInfo_cylSize_get;
*swig_cylSize_set = *LibStoragec::PartitionInfo_cylSize_set;
*swig_partitionType_get = *LibStoragec::PartitionInfo_partitionType_get;
*swig_partitionType_set = *LibStoragec::PartitionInfo_partitionType_set;
*swig_id_get = *LibStoragec::PartitionInfo_id_get;
*swig_id_set = *LibStoragec::PartitionInfo_id_set;
*swig_boot_get = *LibStoragec::PartitionInfo_boot_get;
*swig_boot_set = *LibStoragec::PartitionInfo_boot_set;
*swig_udevPath_get = *LibStoragec::PartitionInfo_udevPath_get;
*swig_udevPath_set = *LibStoragec::PartitionInfo_udevPath_set;
*swig_udevId_get = *LibStoragec::PartitionInfo_udevId_get;
*swig_udevId_set = *LibStoragec::PartitionInfo_udevId_set;
sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        LibStoragec::delete_PartitionInfo($self);
        delete $OWNER{$self};
    }
}

sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : LibStorage::LvmLvInfo ##############

package LibStorage::LvmLvInfo;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( LibStorage );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = LibStoragec::new_LvmLvInfo(@_);
    bless $self, $pkg if defined($self);
}

*swig_v_get = *LibStoragec::LvmLvInfo_v_get;
*swig_v_set = *LibStoragec::LvmLvInfo_v_set;
*swig_stripe_get = *LibStoragec::LvmLvInfo_stripe_get;
*swig_stripe_set = *LibStoragec::LvmLvInfo_stripe_set;
*swig_stripe_size_get = *LibStoragec::LvmLvInfo_stripe_size_get;
*swig_stripe_size_set = *LibStoragec::LvmLvInfo_stripe_size_set;
*swig_uuid_get = *LibStoragec::LvmLvInfo_uuid_get;
*swig_uuid_set = *LibStoragec::LvmLvInfo_uuid_set;
*swig_status_get = *LibStoragec::LvmLvInfo_status_get;
*swig_status_set = *LibStoragec::LvmLvInfo_status_set;
*swig_allocation_get = *LibStoragec::LvmLvInfo_allocation_get;
*swig_allocation_set = *LibStoragec::LvmLvInfo_allocation_set;
*swig_dm_table_get = *LibStoragec::LvmLvInfo_dm_table_get;
*swig_dm_table_set = *LibStoragec::LvmLvInfo_dm_table_set;
*swig_dm_target_get = *LibStoragec::LvmLvInfo_dm_target_get;
*swig_dm_target_set = *LibStoragec::LvmLvInfo_dm_target_set;
sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        LibStoragec::delete_LvmLvInfo($self);
        delete $OWNER{$self};
    }
}

sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : LibStorage::EvmsInfo ##############

package LibStorage::EvmsInfo;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( LibStorage );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = LibStoragec::new_EvmsInfo(@_);
    bless $self, $pkg if defined($self);
}

*swig_v_get = *LibStoragec::EvmsInfo_v_get;
*swig_v_set = *LibStoragec::EvmsInfo_v_set;
*swig_stripe_get = *LibStoragec::EvmsInfo_stripe_get;
*swig_stripe_set = *LibStoragec::EvmsInfo_stripe_set;
*swig_stripe_size_get = *LibStoragec::EvmsInfo_stripe_size_get;
*swig_stripe_size_set = *LibStoragec::EvmsInfo_stripe_size_set;
*swig_compatible_get = *LibStoragec::EvmsInfo_compatible_get;
*swig_compatible_set = *LibStoragec::EvmsInfo_compatible_set;
*swig_dm_table_get = *LibStoragec::EvmsInfo_dm_table_get;
*swig_dm_table_set = *LibStoragec::EvmsInfo_dm_table_set;
*swig_dm_target_get = *LibStoragec::EvmsInfo_dm_target_get;
*swig_dm_target_set = *LibStoragec::EvmsInfo_dm_target_set;
sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        LibStoragec::delete_EvmsInfo($self);
        delete $OWNER{$self};
    }
}

sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : LibStorage::MdInfo ##############

package LibStorage::MdInfo;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( LibStorage );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = LibStoragec::new_MdInfo(@_);
    bless $self, $pkg if defined($self);
}

*swig_v_get = *LibStoragec::MdInfo_v_get;
*swig_v_set = *LibStoragec::MdInfo_v_set;
*swig_nr_get = *LibStoragec::MdInfo_nr_get;
*swig_nr_set = *LibStoragec::MdInfo_nr_set;
*swig_type_get = *LibStoragec::MdInfo_type_get;
*swig_type_set = *LibStoragec::MdInfo_type_set;
*swig_parity_get = *LibStoragec::MdInfo_parity_get;
*swig_parity_set = *LibStoragec::MdInfo_parity_set;
*swig_uuid_get = *LibStoragec::MdInfo_uuid_get;
*swig_uuid_set = *LibStoragec::MdInfo_uuid_set;
*swig_chunk_get = *LibStoragec::MdInfo_chunk_get;
*swig_chunk_set = *LibStoragec::MdInfo_chunk_set;
*swig_devices_get = *LibStoragec::MdInfo_devices_get;
*swig_devices_set = *LibStoragec::MdInfo_devices_set;
sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        LibStoragec::delete_MdInfo($self);
        delete $OWNER{$self};
    }
}

sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : LibStorage::LoopInfo ##############

package LibStorage::LoopInfo;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( LibStorage );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = LibStoragec::new_LoopInfo(@_);
    bless $self, $pkg if defined($self);
}

*swig_v_get = *LibStoragec::LoopInfo_v_get;
*swig_v_set = *LibStoragec::LoopInfo_v_set;
*swig_reuseFile_get = *LibStoragec::LoopInfo_reuseFile_get;
*swig_reuseFile_set = *LibStoragec::LoopInfo_reuseFile_set;
*swig_nr_get = *LibStoragec::LoopInfo_nr_get;
*swig_nr_set = *LibStoragec::LoopInfo_nr_set;
*swig_file_get = *LibStoragec::LoopInfo_file_get;
*swig_file_set = *LibStoragec::LoopInfo_file_set;
sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        LibStoragec::delete_LoopInfo($self);
        delete $OWNER{$self};
    }
}

sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : LibStorage::DmInfo ##############

package LibStorage::DmInfo;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( LibStorage );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = LibStoragec::new_DmInfo(@_);
    bless $self, $pkg if defined($self);
}

*swig_v_get = *LibStoragec::DmInfo_v_get;
*swig_v_set = *LibStoragec::DmInfo_v_set;
*swig_nr_get = *LibStoragec::DmInfo_nr_get;
*swig_nr_set = *LibStoragec::DmInfo_nr_set;
*swig_table_get = *LibStoragec::DmInfo_table_get;
*swig_table_set = *LibStoragec::DmInfo_table_set;
*swig_target_get = *LibStoragec::DmInfo_target_get;
*swig_target_set = *LibStoragec::DmInfo_target_set;
sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        LibStoragec::delete_DmInfo($self);
        delete $OWNER{$self};
    }
}

sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : LibStorage::DmPartInfo ##############

package LibStorage::DmPartInfo;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( LibStorage );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = LibStoragec::new_DmPartInfo(@_);
    bless $self, $pkg if defined($self);
}

*swig_v_get = *LibStoragec::DmPartInfo_v_get;
*swig_v_set = *LibStoragec::DmPartInfo_v_set;
*swig_p_get = *LibStoragec::DmPartInfo_p_get;
*swig_p_set = *LibStoragec::DmPartInfo_p_set;
*swig_part_get = *LibStoragec::DmPartInfo_part_get;
*swig_part_set = *LibStoragec::DmPartInfo_part_set;
*swig_table_get = *LibStoragec::DmPartInfo_table_get;
*swig_table_set = *LibStoragec::DmPartInfo_table_set;
*swig_target_get = *LibStoragec::DmPartInfo_target_get;
*swig_target_set = *LibStoragec::DmPartInfo_target_set;
sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        LibStoragec::delete_DmPartInfo($self);
        delete $OWNER{$self};
    }
}

sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : LibStorage::DmraidInfo ##############

package LibStorage::DmraidInfo;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( LibStorage );
%OWNER = ();
%ITERATORS = ();
sub new {
    my $pkg = shift;
    my $self = LibStoragec::new_DmraidInfo(@_);
    bless $self, $pkg if defined($self);
}

*swig_p_get = *LibStoragec::DmraidInfo_p_get;
*swig_p_set = *LibStoragec::DmraidInfo_p_set;
sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        LibStoragec::delete_DmraidInfo($self);
        delete $OWNER{$self};
    }
}

sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


############# Class : LibStorage::StorageInterface ##############

package LibStorage::StorageInterface;
use vars qw(@ISA %OWNER %ITERATORS %BLESSEDMEMBERS);
@ISA = qw( LibStorage );
%OWNER = ();
%ITERATORS = ();
sub DESTROY {
    return unless $_[0]->isa('HASH');
    my $self = tied(%{$_[0]});
    return unless defined $self;
    delete $ITERATORS{$self};
    if (exists $OWNER{$self}) {
        LibStoragec::delete_StorageInterface($self);
        delete $OWNER{$self};
    }
}

*getContainers = *LibStoragec::StorageInterface_getContainers;
*getDiskInfo = *LibStoragec::StorageInterface_getDiskInfo;
*getContDiskInfo = *LibStoragec::StorageInterface_getContDiskInfo;
*getLvmVgInfo = *LibStoragec::StorageInterface_getLvmVgInfo;
*getContLvmVgInfo = *LibStoragec::StorageInterface_getContLvmVgInfo;
*getEvmsCoInfo = *LibStoragec::StorageInterface_getEvmsCoInfo;
*getContEvmsCoInfo = *LibStoragec::StorageInterface_getContEvmsCoInfo;
*getDmraidCoInfo = *LibStoragec::StorageInterface_getDmraidCoInfo;
*getContDmraidCoInfo = *LibStoragec::StorageInterface_getContDmraidCoInfo;
*getVolumes = *LibStoragec::StorageInterface_getVolumes;
*getVolume = *LibStoragec::StorageInterface_getVolume;
*getPartitionInfo = *LibStoragec::StorageInterface_getPartitionInfo;
*getLvmLvInfo = *LibStoragec::StorageInterface_getLvmLvInfo;
*getEvmsInfo = *LibStoragec::StorageInterface_getEvmsInfo;
*getMdInfo = *LibStoragec::StorageInterface_getMdInfo;
*getLoopInfo = *LibStoragec::StorageInterface_getLoopInfo;
*getDmInfo = *LibStoragec::StorageInterface_getDmInfo;
*getDmraidInfo = *LibStoragec::StorageInterface_getDmraidInfo;
*getFsCapabilities = *LibStoragec::StorageInterface_getFsCapabilities;
*printInfo = *LibStoragec::StorageInterface_printInfo;
*printInfoCo = *LibStoragec::StorageInterface_printInfoCo;
*createPartition = *LibStoragec::StorageInterface_createPartition;
*resizePartition = *LibStoragec::StorageInterface_resizePartition;
*resizePartitionNoFs = *LibStoragec::StorageInterface_resizePartitionNoFs;
*updatePartitionArea = *LibStoragec::StorageInterface_updatePartitionArea;
*nextFreePartition = *LibStoragec::StorageInterface_nextFreePartition;
*createPartitionKb = *LibStoragec::StorageInterface_createPartitionKb;
*createPartitionAny = *LibStoragec::StorageInterface_createPartitionAny;
*createPartitionMax = *LibStoragec::StorageInterface_createPartitionMax;
*cylinderToKb = *LibStoragec::StorageInterface_cylinderToKb;
*kbToCylinder = *LibStoragec::StorageInterface_kbToCylinder;
*removePartition = *LibStoragec::StorageInterface_removePartition;
*changePartitionId = *LibStoragec::StorageInterface_changePartitionId;
*forgetChangePartitionId = *LibStoragec::StorageInterface_forgetChangePartitionId;
*destroyPartitionTable = *LibStoragec::StorageInterface_destroyPartitionTable;
*initializeDisk = *LibStoragec::StorageInterface_initializeDisk;
*defaultDiskLabel = *LibStoragec::StorageInterface_defaultDiskLabel;
*changeFormatVolume = *LibStoragec::StorageInterface_changeFormatVolume;
*changeLabelVolume = *LibStoragec::StorageInterface_changeLabelVolume;
*changeMkfsOptVolume = *LibStoragec::StorageInterface_changeMkfsOptVolume;
*changeMountPoint = *LibStoragec::StorageInterface_changeMountPoint;
*getMountPoint = *LibStoragec::StorageInterface_getMountPoint;
*changeMountBy = *LibStoragec::StorageInterface_changeMountBy;
*getMountBy = *LibStoragec::StorageInterface_getMountBy;
*changeFstabOptions = *LibStoragec::StorageInterface_changeFstabOptions;
*getFstabOptions = *LibStoragec::StorageInterface_getFstabOptions;
*addFstabOptions = *LibStoragec::StorageInterface_addFstabOptions;
*removeFstabOptions = *LibStoragec::StorageInterface_removeFstabOptions;
*setCryptPassword = *LibStoragec::StorageInterface_setCryptPassword;
*forgetCryptPassword = *LibStoragec::StorageInterface_forgetCryptPassword;
*getCryptPassword = *LibStoragec::StorageInterface_getCryptPassword;
*setCrypt = *LibStoragec::StorageInterface_setCrypt;
*getCrypt = *LibStoragec::StorageInterface_getCrypt;
*setIgnoreFstab = *LibStoragec::StorageInterface_setIgnoreFstab;
*getIgnoreFstab = *LibStoragec::StorageInterface_getIgnoreFstab;
*changeDescText = *LibStoragec::StorageInterface_changeDescText;
*addFstabEntry = *LibStoragec::StorageInterface_addFstabEntry;
*resizeVolume = *LibStoragec::StorageInterface_resizeVolume;
*resizeVolumeNoFs = *LibStoragec::StorageInterface_resizeVolumeNoFs;
*forgetResizeVolume = *LibStoragec::StorageInterface_forgetResizeVolume;
*setRecursiveRemoval = *LibStoragec::StorageInterface_setRecursiveRemoval;
*getRecursiveRemoval = *LibStoragec::StorageInterface_getRecursiveRemoval;
*setZeroNewPartitions = *LibStoragec::StorageInterface_setZeroNewPartitions;
*getZeroNewPartitions = *LibStoragec::StorageInterface_getZeroNewPartitions;
*setDefaultMountBy = *LibStoragec::StorageInterface_setDefaultMountBy;
*getDefaultMountBy = *LibStoragec::StorageInterface_getDefaultMountBy;
*setRootPrefix = *LibStoragec::StorageInterface_setRootPrefix;
*setDetectMountedVolumes = *LibStoragec::StorageInterface_setDetectMountedVolumes;
*getDetectMountedVolumes = *LibStoragec::StorageInterface_getDetectMountedVolumes;
*removeVolume = *LibStoragec::StorageInterface_removeVolume;
*createLvmVg = *LibStoragec::StorageInterface_createLvmVg;
*removeLvmVg = *LibStoragec::StorageInterface_removeLvmVg;
*extendLvmVg = *LibStoragec::StorageInterface_extendLvmVg;
*shrinkLvmVg = *LibStoragec::StorageInterface_shrinkLvmVg;
*createLvmLv = *LibStoragec::StorageInterface_createLvmLv;
*removeLvmLvByDevice = *LibStoragec::StorageInterface_removeLvmLvByDevice;
*removeLvmLv = *LibStoragec::StorageInterface_removeLvmLv;
*changeLvStripeSize = *LibStoragec::StorageInterface_changeLvStripeSize;
*createEvmsContainer = *LibStoragec::StorageInterface_createEvmsContainer;
*modifyEvmsContainer = *LibStoragec::StorageInterface_modifyEvmsContainer;
*removeEvmsContainer = *LibStoragec::StorageInterface_removeEvmsContainer;
*extendEvmsContainer = *LibStoragec::StorageInterface_extendEvmsContainer;
*shrinkEvmsContainer = *LibStoragec::StorageInterface_shrinkEvmsContainer;
*createEvmsVolume = *LibStoragec::StorageInterface_createEvmsVolume;
*removeEvmsVolumeByDevice = *LibStoragec::StorageInterface_removeEvmsVolumeByDevice;
*removeEvmsVolume = *LibStoragec::StorageInterface_removeEvmsVolume;
*changeEvmsStripeSize = *LibStoragec::StorageInterface_changeEvmsStripeSize;
*evmsActivate = *LibStoragec::StorageInterface_evmsActivate;
*createMd = *LibStoragec::StorageInterface_createMd;
*createMdAny = *LibStoragec::StorageInterface_createMdAny;
*removeMd = *LibStoragec::StorageInterface_removeMd;
*extendMd = *LibStoragec::StorageInterface_extendMd;
*shrinkMd = *LibStoragec::StorageInterface_shrinkMd;
*changeMdType = *LibStoragec::StorageInterface_changeMdType;
*changeMdChunk = *LibStoragec::StorageInterface_changeMdChunk;
*changeMdParity = *LibStoragec::StorageInterface_changeMdParity;
*checkMd = *LibStoragec::StorageInterface_checkMd;
*createFileLoop = *LibStoragec::StorageInterface_createFileLoop;
*modifyFileLoop = *LibStoragec::StorageInterface_modifyFileLoop;
*removeFileLoop = *LibStoragec::StorageInterface_removeFileLoop;
*removeDmraid = *LibStoragec::StorageInterface_removeDmraid;
*getCommitActions = *LibStoragec::StorageInterface_getCommitActions;
*getLastAction = *LibStoragec::StorageInterface_getLastAction;
*getExtendedErrorMessage = *LibStoragec::StorageInterface_getExtendedErrorMessage;
*setCacheChanges = *LibStoragec::StorageInterface_setCacheChanges;
*isCacheChanges = *LibStoragec::StorageInterface_isCacheChanges;
*commit = *LibStoragec::StorageInterface_commit;
*createBackupState = *LibStoragec::StorageInterface_createBackupState;
*restoreBackupState = *LibStoragec::StorageInterface_restoreBackupState;
*checkBackupState = *LibStoragec::StorageInterface_checkBackupState;
*equalBackupStates = *LibStoragec::StorageInterface_equalBackupStates;
*removeBackupState = *LibStoragec::StorageInterface_removeBackupState;
*checkDeviceMounted = *LibStoragec::StorageInterface_checkDeviceMounted;
*umountDevice = *LibStoragec::StorageInterface_umountDevice;
*mountDevice = *LibStoragec::StorageInterface_mountDevice;
*checkDmMapsTo = *LibStoragec::StorageInterface_checkDmMapsTo;
*removeDmMapsTo = *LibStoragec::StorageInterface_removeDmMapsTo;
*getFreeInfo = *LibStoragec::StorageInterface_getFreeInfo;
*readFstab = *LibStoragec::StorageInterface_readFstab;
*activateHld = *LibStoragec::StorageInterface_activateHld;
*rescanEverything = *LibStoragec::StorageInterface_rescanEverything;
*dumpObjectList = *LibStoragec::StorageInterface_dumpObjectList;
sub DISOWN {
    my $self = shift;
    my $ptr = tied(%$self);
    delete $OWNER{$ptr};
}

sub ACQUIRE {
    my $self = shift;
    my $ptr = tied(%$self);
    $OWNER{$ptr} = 1;
}


# ------- VARIABLE STUBS --------

package LibStorage;

*FSUNKNOWN = *LibStoragec::FSUNKNOWN;
*REISERFS = *LibStoragec::REISERFS;
*EXT2 = *LibStoragec::EXT2;
*EXT3 = *LibStoragec::EXT3;
*VFAT = *LibStoragec::VFAT;
*XFS = *LibStoragec::XFS;
*JFS = *LibStoragec::JFS;
*HFS = *LibStoragec::HFS;
*NTFS = *LibStoragec::NTFS;
*SWAP = *LibStoragec::SWAP;
*FSNONE = *LibStoragec::FSNONE;
*PRIMARY = *LibStoragec::PRIMARY;
*EXTENDED = *LibStoragec::EXTENDED;
*LOGICAL = *LibStoragec::LOGICAL;
*PTYPE_ANY = *LibStoragec::PTYPE_ANY;
*MOUNTBY_DEVICE = *LibStoragec::MOUNTBY_DEVICE;
*MOUNTBY_UUID = *LibStoragec::MOUNTBY_UUID;
*MOUNTBY_LABEL = *LibStoragec::MOUNTBY_LABEL;
*MOUNTBY_ID = *LibStoragec::MOUNTBY_ID;
*MOUNTBY_PATH = *LibStoragec::MOUNTBY_PATH;
*ENC_NONE = *LibStoragec::ENC_NONE;
*ENC_TWOFISH = *LibStoragec::ENC_TWOFISH;
*ENC_TWOFISH_OLD = *LibStoragec::ENC_TWOFISH_OLD;
*ENC_TWOFISH256_OLD = *LibStoragec::ENC_TWOFISH256_OLD;
*ENC_UNKNOWN = *LibStoragec::ENC_UNKNOWN;
*RAID_UNK = *LibStoragec::RAID_UNK;
*RAID0 = *LibStoragec::RAID0;
*RAID1 = *LibStoragec::RAID1;
*RAID5 = *LibStoragec::RAID5;
*RAID6 = *LibStoragec::RAID6;
*RAID10 = *LibStoragec::RAID10;
*MULTIPATH = *LibStoragec::MULTIPATH;
*PAR_NONE = *LibStoragec::PAR_NONE;
*LEFT_ASYMMETRIC = *LibStoragec::LEFT_ASYMMETRIC;
*LEFT_SYMMETRIC = *LibStoragec::LEFT_SYMMETRIC;
*RIGHT_ASYMMETRIC = *LibStoragec::RIGHT_ASYMMETRIC;
*RIGHT_SYMMETRIC = *LibStoragec::RIGHT_SYMMETRIC;
*UB_NONE = *LibStoragec::UB_NONE;
*UB_LVM = *LibStoragec::UB_LVM;
*UB_MD = *LibStoragec::UB_MD;
*UB_EVMS = *LibStoragec::UB_EVMS;
*UB_DM = *LibStoragec::UB_DM;
*UB_DMRAID = *LibStoragec::UB_DMRAID;
*CUNKNOWN = *LibStoragec::CUNKNOWN;
*DISK = *LibStoragec::DISK;
*MD = *LibStoragec::MD;
*LOOP = *LibStoragec::LOOP;
*LVM = *LibStoragec::LVM;
*DM = *LibStoragec::DM;
*EVMS = *LibStoragec::EVMS;
*DMRAID = *LibStoragec::DMRAID;
*COTYPE_LAST_ENTRY = *LibStoragec::COTYPE_LAST_ENTRY;
*DISK_PARTITION_OVERLAPS_EXISTING = *LibStoragec::DISK_PARTITION_OVERLAPS_EXISTING;
*DISK_PARTITION_EXCEEDS_DISK = *LibStoragec::DISK_PARTITION_EXCEEDS_DISK;
*DISK_CREATE_PARTITION_EXT_ONLY_ONCE = *LibStoragec::DISK_CREATE_PARTITION_EXT_ONLY_ONCE;
*DISK_CREATE_PARTITION_EXT_IMPOSSIBLE = *LibStoragec::DISK_CREATE_PARTITION_EXT_IMPOSSIBLE;
*DISK_PARTITION_NO_FREE_NUMBER = *LibStoragec::DISK_PARTITION_NO_FREE_NUMBER;
*DISK_CREATE_PARTITION_INVALID_VOLUME = *LibStoragec::DISK_CREATE_PARTITION_INVALID_VOLUME;
*DISK_CREATE_PARTITION_INVALID_TYPE = *LibStoragec::DISK_CREATE_PARTITION_INVALID_TYPE;
*DISK_CREATE_PARTITION_PARTED_FAILED = *LibStoragec::DISK_CREATE_PARTITION_PARTED_FAILED;
*DISK_PARTITION_NOT_FOUND = *LibStoragec::DISK_PARTITION_NOT_FOUND;
*DISK_CREATE_PARTITION_LOGICAL_NO_EXT = *LibStoragec::DISK_CREATE_PARTITION_LOGICAL_NO_EXT;
*DISK_PARTITION_LOGICAL_OUTSIDE_EXT = *LibStoragec::DISK_PARTITION_LOGICAL_OUTSIDE_EXT;
*DISK_SET_TYPE_INVALID_VOLUME = *LibStoragec::DISK_SET_TYPE_INVALID_VOLUME;
*DISK_SET_TYPE_PARTED_FAILED = *LibStoragec::DISK_SET_TYPE_PARTED_FAILED;
*DISK_SET_LABEL_PARTED_FAILED = *LibStoragec::DISK_SET_LABEL_PARTED_FAILED;
*DISK_REMOVE_PARTITION_PARTED_FAILED = *LibStoragec::DISK_REMOVE_PARTITION_PARTED_FAILED;
*DISK_REMOVE_PARTITION_INVALID_VOLUME = *LibStoragec::DISK_REMOVE_PARTITION_INVALID_VOLUME;
*DISK_REMOVE_PARTITION_LIST_ERASE = *LibStoragec::DISK_REMOVE_PARTITION_LIST_ERASE;
*DISK_DESTROY_TABLE_INVALID_LABEL = *LibStoragec::DISK_DESTROY_TABLE_INVALID_LABEL;
*DISK_PARTITION_ZERO_SIZE = *LibStoragec::DISK_PARTITION_ZERO_SIZE;
*DISK_CHANGE_READONLY = *LibStoragec::DISK_CHANGE_READONLY;
*DISK_RESIZE_PARTITION_INVALID_VOLUME = *LibStoragec::DISK_RESIZE_PARTITION_INVALID_VOLUME;
*DISK_RESIZE_PARTITION_PARTED_FAILED = *LibStoragec::DISK_RESIZE_PARTITION_PARTED_FAILED;
*DISK_RESIZE_NO_SPACE = *LibStoragec::DISK_RESIZE_NO_SPACE;
*DISK_CHECK_RESIZE_INVALID_VOLUME = *LibStoragec::DISK_CHECK_RESIZE_INVALID_VOLUME;
*DISK_REMOVE_PARTITION_CREATE_NOT_FOUND = *LibStoragec::DISK_REMOVE_PARTITION_CREATE_NOT_FOUND;
*DISK_COMMIT_NOTHING_TODO = *LibStoragec::DISK_COMMIT_NOTHING_TODO;
*DISK_CREATE_PARTITION_NO_SPACE = *LibStoragec::DISK_CREATE_PARTITION_NO_SPACE;
*DISK_REMOVE_USED_BY = *LibStoragec::DISK_REMOVE_USED_BY;
*DISK_INIT_NOT_POSSIBLE = *LibStoragec::DISK_INIT_NOT_POSSIBLE;
*STORAGE_DISK_NOT_FOUND = *LibStoragec::STORAGE_DISK_NOT_FOUND;
*STORAGE_VOLUME_NOT_FOUND = *LibStoragec::STORAGE_VOLUME_NOT_FOUND;
*STORAGE_REMOVE_PARTITION_INVALID_CONTAINER = *LibStoragec::STORAGE_REMOVE_PARTITION_INVALID_CONTAINER;
*STORAGE_CHANGE_PARTITION_ID_INVALID_CONTAINER = *LibStoragec::STORAGE_CHANGE_PARTITION_ID_INVALID_CONTAINER;
*STORAGE_CHANGE_READONLY = *LibStoragec::STORAGE_CHANGE_READONLY;
*STORAGE_DISK_USED_BY = *LibStoragec::STORAGE_DISK_USED_BY;
*STORAGE_LVM_VG_EXISTS = *LibStoragec::STORAGE_LVM_VG_EXISTS;
*STORAGE_LVM_VG_NOT_FOUND = *LibStoragec::STORAGE_LVM_VG_NOT_FOUND;
*STORAGE_LVM_INVALID_DEVICE = *LibStoragec::STORAGE_LVM_INVALID_DEVICE;
*STORAGE_CONTAINER_NOT_FOUND = *LibStoragec::STORAGE_CONTAINER_NOT_FOUND;
*STORAGE_VG_INVALID_NAME = *LibStoragec::STORAGE_VG_INVALID_NAME;
*STORAGE_REMOVE_USED_VOLUME = *LibStoragec::STORAGE_REMOVE_USED_VOLUME;
*STORAGE_REMOVE_USING_UNKNOWN_TYPE = *LibStoragec::STORAGE_REMOVE_USING_UNKNOWN_TYPE;
*STORAGE_NOT_YET_IMPLEMENTED = *LibStoragec::STORAGE_NOT_YET_IMPLEMENTED;
*STORAGE_MD_INVALID_NAME = *LibStoragec::STORAGE_MD_INVALID_NAME;
*STORAGE_MD_NOT_FOUND = *LibStoragec::STORAGE_MD_NOT_FOUND;
*STORAGE_MEMORY_EXHAUSTED = *LibStoragec::STORAGE_MEMORY_EXHAUSTED;
*STORAGE_LOOP_NOT_FOUND = *LibStoragec::STORAGE_LOOP_NOT_FOUND;
*STORAGE_CREATED_LOOP_NOT_FOUND = *LibStoragec::STORAGE_CREATED_LOOP_NOT_FOUND;
*STORAGE_EVMS_INVALID_NAME = *LibStoragec::STORAGE_EVMS_INVALID_NAME;
*STORAGE_EVMS_CO_EXISTS = *LibStoragec::STORAGE_EVMS_CO_EXISTS;
*STORAGE_EVMS_CO_NOT_FOUND = *LibStoragec::STORAGE_EVMS_CO_NOT_FOUND;
*STORAGE_EVMS_INVALID_DEVICE = *LibStoragec::STORAGE_EVMS_INVALID_DEVICE;
*STORAGE_CHANGE_AREA_INVALID_CONTAINER = *LibStoragec::STORAGE_CHANGE_AREA_INVALID_CONTAINER;
*STORAGE_BACKUP_STATE_NOT_FOUND = *LibStoragec::STORAGE_BACKUP_STATE_NOT_FOUND;
*STORAGE_INVALID_FSTAB_VALUE = *LibStoragec::STORAGE_INVALID_FSTAB_VALUE;
*STORAGE_NO_FSTAB_PTR = *LibStoragec::STORAGE_NO_FSTAB_PTR;
*STORAGE_DEVICE_NODE_NOT_FOUND = *LibStoragec::STORAGE_DEVICE_NODE_NOT_FOUND;
*STORAGE_DMRAID_CO_NOT_FOUND = *LibStoragec::STORAGE_DMRAID_CO_NOT_FOUND;
*STORAGE_RESIZE_INVALID_CONTAINER = *LibStoragec::STORAGE_RESIZE_INVALID_CONTAINER;
*VOLUME_COMMIT_UNKNOWN_STAGE = *LibStoragec::VOLUME_COMMIT_UNKNOWN_STAGE;
*VOLUME_FSTAB_EMPTY_MOUNT = *LibStoragec::VOLUME_FSTAB_EMPTY_MOUNT;
*VOLUME_UMOUNT_FAILED = *LibStoragec::VOLUME_UMOUNT_FAILED;
*VOLUME_MOUNT_FAILED = *LibStoragec::VOLUME_MOUNT_FAILED;
*VOLUME_FORMAT_DD_FAILED = *LibStoragec::VOLUME_FORMAT_DD_FAILED;
*VOLUME_FORMAT_UNKNOWN_FS = *LibStoragec::VOLUME_FORMAT_UNKNOWN_FS;
*VOLUME_FORMAT_FS_UNDETECTED = *LibStoragec::VOLUME_FORMAT_FS_UNDETECTED;
*VOLUME_FORMAT_FS_TOO_SMALL = *LibStoragec::VOLUME_FORMAT_FS_TOO_SMALL;
*VOLUME_FORMAT_FAILED = *LibStoragec::VOLUME_FORMAT_FAILED;
*VOLUME_TUNE2FS_FAILED = *LibStoragec::VOLUME_TUNE2FS_FAILED;
*VOLUME_MKLABEL_FS_UNABLE = *LibStoragec::VOLUME_MKLABEL_FS_UNABLE;
*VOLUME_MKLABEL_FAILED = *LibStoragec::VOLUME_MKLABEL_FAILED;
*VOLUME_LOSETUP_NO_LOOP = *LibStoragec::VOLUME_LOSETUP_NO_LOOP;
*VOLUME_LOSETUP_FAILED = *LibStoragec::VOLUME_LOSETUP_FAILED;
*VOLUME_CRYPT_NO_PWD = *LibStoragec::VOLUME_CRYPT_NO_PWD;
*VOLUME_CRYPT_PWD_TOO_SHORT = *LibStoragec::VOLUME_CRYPT_PWD_TOO_SHORT;
*VOLUME_CRYPT_NOT_DETECTED = *LibStoragec::VOLUME_CRYPT_NOT_DETECTED;
*VOLUME_FORMAT_EXTENDED_UNSUPPORTED = *LibStoragec::VOLUME_FORMAT_EXTENDED_UNSUPPORTED;
*VOLUME_MOUNT_EXTENDED_UNSUPPORTED = *LibStoragec::VOLUME_MOUNT_EXTENDED_UNSUPPORTED;
*VOLUME_MOUNT_POINT_INVALID = *LibStoragec::VOLUME_MOUNT_POINT_INVALID;
*VOLUME_MOUNTBY_NOT_ENCRYPTED = *LibStoragec::VOLUME_MOUNTBY_NOT_ENCRYPTED;
*VOLUME_MOUNTBY_UNSUPPORTED_BY_FS = *LibStoragec::VOLUME_MOUNTBY_UNSUPPORTED_BY_FS;
*VOLUME_LABEL_NOT_SUPPORTED = *LibStoragec::VOLUME_LABEL_NOT_SUPPORTED;
*VOLUME_LABEL_TOO_LONG = *LibStoragec::VOLUME_LABEL_TOO_LONG;
*VOLUME_LABEL_WHILE_MOUNTED = *LibStoragec::VOLUME_LABEL_WHILE_MOUNTED;
*VOLUME_RESIZE_UNSUPPORTED_BY_FS = *LibStoragec::VOLUME_RESIZE_UNSUPPORTED_BY_FS;
*VOLUME_RESIZE_UNSUPPORTED_BY_CONTAINER = *LibStoragec::VOLUME_RESIZE_UNSUPPORTED_BY_CONTAINER;
*VOLUME_RESIZE_FAILED = *LibStoragec::VOLUME_RESIZE_FAILED;
*VOLUME_ALREADY_IN_USE = *LibStoragec::VOLUME_ALREADY_IN_USE;
*VOLUME_LOUNSETUP_FAILED = *LibStoragec::VOLUME_LOUNSETUP_FAILED;
*VOLUME_DEVICE_NOT_PRESENT = *LibStoragec::VOLUME_DEVICE_NOT_PRESENT;
*VOLUME_DEVICE_NOT_BLOCK = *LibStoragec::VOLUME_DEVICE_NOT_BLOCK;
*VOLUME_MOUNTBY_UNSUPPORTED_BY_VOLUME = *LibStoragec::VOLUME_MOUNTBY_UNSUPPORTED_BY_VOLUME;
*LVM_CREATE_PV_FAILED = *LibStoragec::LVM_CREATE_PV_FAILED;
*LVM_PV_ALREADY_CONTAINED = *LibStoragec::LVM_PV_ALREADY_CONTAINED;
*LVM_PV_DEVICE_UNKNOWN = *LibStoragec::LVM_PV_DEVICE_UNKNOWN;
*LVM_PV_DEVICE_USED = *LibStoragec::LVM_PV_DEVICE_USED;
*LVM_VG_HAS_NONE_PV = *LibStoragec::LVM_VG_HAS_NONE_PV;
*LVM_LV_INVALID_NAME = *LibStoragec::LVM_LV_INVALID_NAME;
*LVM_LV_DUPLICATE_NAME = *LibStoragec::LVM_LV_DUPLICATE_NAME;
*LVM_LV_NO_SPACE = *LibStoragec::LVM_LV_NO_SPACE;
*LVM_LV_UNKNOWN_NAME = *LibStoragec::LVM_LV_UNKNOWN_NAME;
*LVM_LV_NOT_IN_LIST = *LibStoragec::LVM_LV_NOT_IN_LIST;
*LVM_VG_CREATE_FAILED = *LibStoragec::LVM_VG_CREATE_FAILED;
*LVM_VG_EXTEND_FAILED = *LibStoragec::LVM_VG_EXTEND_FAILED;
*LVM_VG_REDUCE_FAILED = *LibStoragec::LVM_VG_REDUCE_FAILED;
*LVM_VG_REMOVE_FAILED = *LibStoragec::LVM_VG_REMOVE_FAILED;
*LVM_LV_CREATE_FAILED = *LibStoragec::LVM_LV_CREATE_FAILED;
*LVM_LV_REMOVE_FAILED = *LibStoragec::LVM_LV_REMOVE_FAILED;
*LVM_LV_RESIZE_FAILED = *LibStoragec::LVM_LV_RESIZE_FAILED;
*LVM_PV_STILL_ADDED = *LibStoragec::LVM_PV_STILL_ADDED;
*LVM_PV_REMOVE_NOT_FOUND = *LibStoragec::LVM_PV_REMOVE_NOT_FOUND;
*LVM_CREATE_LV_INVALID_VOLUME = *LibStoragec::LVM_CREATE_LV_INVALID_VOLUME;
*LVM_REMOVE_LV_INVALID_VOLUME = *LibStoragec::LVM_REMOVE_LV_INVALID_VOLUME;
*LVM_RESIZE_LV_INVALID_VOLUME = *LibStoragec::LVM_RESIZE_LV_INVALID_VOLUME;
*LVM_CHANGE_READONLY = *LibStoragec::LVM_CHANGE_READONLY;
*LVM_CHECK_RESIZE_INVALID_VOLUME = *LibStoragec::LVM_CHECK_RESIZE_INVALID_VOLUME;
*LVM_COMMIT_NOTHING_TODO = *LibStoragec::LVM_COMMIT_NOTHING_TODO;
*LVM_LV_REMOVE_USED_BY = *LibStoragec::LVM_LV_REMOVE_USED_BY;
*LVM_LV_ALREADY_ON_DISK = *LibStoragec::LVM_LV_ALREADY_ON_DISK;
*LVM_LV_NO_STRIPE_SIZE = *LibStoragec::LVM_LV_NO_STRIPE_SIZE;
*FSTAB_ENTRY_NOT_FOUND = *LibStoragec::FSTAB_ENTRY_NOT_FOUND;
*FSTAB_CHANGE_PREFIX_IMPOSSIBLE = *LibStoragec::FSTAB_CHANGE_PREFIX_IMPOSSIBLE;
*FSTAB_REMOVE_ENTRY_NOT_FOUND = *LibStoragec::FSTAB_REMOVE_ENTRY_NOT_FOUND;
*FSTAB_UPDATE_ENTRY_NOT_FOUND = *LibStoragec::FSTAB_UPDATE_ENTRY_NOT_FOUND;
*FSTAB_ADD_ENTRY_FOUND = *LibStoragec::FSTAB_ADD_ENTRY_FOUND;
*MD_CHANGE_READONLY = *LibStoragec::MD_CHANGE_READONLY;
*MD_DUPLICATE_NUMBER = *LibStoragec::MD_DUPLICATE_NUMBER;
*MD_TOO_FEW_DEVICES = *LibStoragec::MD_TOO_FEW_DEVICES;
*MD_DEVICE_UNKNOWN = *LibStoragec::MD_DEVICE_UNKNOWN;
*MD_DEVICE_USED = *LibStoragec::MD_DEVICE_USED;
*MD_CREATE_INVALID_VOLUME = *LibStoragec::MD_CREATE_INVALID_VOLUME;
*MD_REMOVE_FAILED = *LibStoragec::MD_REMOVE_FAILED;
*MD_NOT_IN_LIST = *LibStoragec::MD_NOT_IN_LIST;
*MD_CREATE_FAILED = *LibStoragec::MD_CREATE_FAILED;
*MD_UNKNOWN_NUMBER = *LibStoragec::MD_UNKNOWN_NUMBER;
*MD_REMOVE_USED_BY = *LibStoragec::MD_REMOVE_USED_BY;
*MD_NUMBER_TOO_LARGE = *LibStoragec::MD_NUMBER_TOO_LARGE;
*MD_REMOVE_INVALID_VOLUME = *LibStoragec::MD_REMOVE_INVALID_VOLUME;
*MD_REMOVE_CREATE_NOT_FOUND = *LibStoragec::MD_REMOVE_CREATE_NOT_FOUND;
*MD_NO_RESIZE_ON_DISK = *LibStoragec::MD_NO_RESIZE_ON_DISK;
*MD_ADD_DUPLICATE = *LibStoragec::MD_ADD_DUPLICATE;
*MD_REMOVE_NONEXISTENT = *LibStoragec::MD_REMOVE_NONEXISTENT;
*MD_NO_CHANGE_ON_DISK = *LibStoragec::MD_NO_CHANGE_ON_DISK;
*MD_NO_CREATE_UNKNOWN = *LibStoragec::MD_NO_CREATE_UNKNOWN;
*LOOP_CHANGE_READONLY = *LibStoragec::LOOP_CHANGE_READONLY;
*LOOP_DUPLICATE_FILE = *LibStoragec::LOOP_DUPLICATE_FILE;
*LOOP_UNKNOWN_FILE = *LibStoragec::LOOP_UNKNOWN_FILE;
*LOOP_REMOVE_USED_BY = *LibStoragec::LOOP_REMOVE_USED_BY;
*LOOP_FILE_CREATE_FAILED = *LibStoragec::LOOP_FILE_CREATE_FAILED;
*LOOP_CREATE_INVALID_VOLUME = *LibStoragec::LOOP_CREATE_INVALID_VOLUME;
*LOOP_REMOVE_FILE_FAILED = *LibStoragec::LOOP_REMOVE_FILE_FAILED;
*LOOP_REMOVE_INVALID_VOLUME = *LibStoragec::LOOP_REMOVE_INVALID_VOLUME;
*LOOP_NOT_IN_LIST = *LibStoragec::LOOP_NOT_IN_LIST;
*LOOP_REMOVE_CREATE_NOT_FOUND = *LibStoragec::LOOP_REMOVE_CREATE_NOT_FOUND;
*LOOP_MODIFY_EXISTING = *LibStoragec::LOOP_MODIFY_EXISTING;
*EVMS_HELPER_UNKNOWN_CMD = *LibStoragec::EVMS_HELPER_UNKNOWN_CMD;
*EVMS_UNSUPPORTED_CONTAINER_TYPE = *LibStoragec::EVMS_UNSUPPORTED_CONTAINER_TYPE;
*EVMS_MALLOC_FAILED = *LibStoragec::EVMS_MALLOC_FAILED;
*EVMS_INVALID_PHYSICAL_VOLUME = *LibStoragec::EVMS_INVALID_PHYSICAL_VOLUME;
*EVMS_PHYSICAL_VOLUME_IN_USE = *LibStoragec::EVMS_PHYSICAL_VOLUME_IN_USE;
*EVMS_PLUGIN_NOT_FOUND = *LibStoragec::EVMS_PLUGIN_NOT_FOUND;
*EVMS_CREATE_CONTAINER_FAILED = *LibStoragec::EVMS_CREATE_CONTAINER_FAILED;
*EVMS_RESIZE_VOLUME_NOT_FOUND = *LibStoragec::EVMS_RESIZE_VOLUME_NOT_FOUND;
*EVMS_RESIZE_CONTAINER_NOT_FOUND = *LibStoragec::EVMS_RESIZE_CONTAINER_NOT_FOUND;
*EVMS_RESIZE_EXPAND_FAILED = *LibStoragec::EVMS_RESIZE_EXPAND_FAILED;
*EVMS_RESIZE_SHRINK_FAILED = *LibStoragec::EVMS_RESIZE_SHRINK_FAILED;
*EVMS_COMMIT_FAILED = *LibStoragec::EVMS_COMMIT_FAILED;
*EVMS_CREATE_VOLUME_FREESPACE_NOT_FOUND = *LibStoragec::EVMS_CREATE_VOLUME_FREESPACE_NOT_FOUND;
*EVMS_CREATE_VOLUME_FAILED = *LibStoragec::EVMS_CREATE_VOLUME_FAILED;
*EVMS_CREATE_COMPAT_VOLUME_FAILED = *LibStoragec::EVMS_CREATE_COMPAT_VOLUME_FAILED;
*EVMS_SEGMENT_NOT_FOUND = *LibStoragec::EVMS_SEGMENT_NOT_FOUND;
*EVMS_REMOVE_VOLUME_NOT_FOUND = *LibStoragec::EVMS_REMOVE_VOLUME_NOT_FOUND;
*EVMS_REMOVE_REGION_FAILED = *LibStoragec::EVMS_REMOVE_REGION_FAILED;
*EVMS_CONTAINER_NOT_FOUND = *LibStoragec::EVMS_CONTAINER_NOT_FOUND;
*EVMS_CONTAINER_EXPAND_FAILED = *LibStoragec::EVMS_CONTAINER_EXPAND_FAILED;
*EVMS_CONTAINER_SHRINK_INVALID_SEGMENT = *LibStoragec::EVMS_CONTAINER_SHRINK_INVALID_SEGMENT;
*EVMS_CONTAINER_SHRINK_FAILED = *LibStoragec::EVMS_CONTAINER_SHRINK_FAILED;
*EVMS_CONTAINER_REMOVE_FAILED = *LibStoragec::EVMS_CONTAINER_REMOVE_FAILED;
*EVMS_PV_ALREADY_CONTAINED = *LibStoragec::EVMS_PV_ALREADY_CONTAINED;
*EVMS_PV_DEVICE_UNKNOWN = *LibStoragec::EVMS_PV_DEVICE_UNKNOWN;
*EVMS_PV_DEVICE_USED = *LibStoragec::EVMS_PV_DEVICE_USED;
*EVMS_CO_HAS_NONE_PV = *LibStoragec::EVMS_CO_HAS_NONE_PV;
*EVMS_LV_INVALID_NAME = *LibStoragec::EVMS_LV_INVALID_NAME;
*EVMS_LV_DUPLICATE_NAME = *LibStoragec::EVMS_LV_DUPLICATE_NAME;
*EVMS_LV_NO_SPACE = *LibStoragec::EVMS_LV_NO_SPACE;
*EVMS_LV_UNKNOWN_NAME = *LibStoragec::EVMS_LV_UNKNOWN_NAME;
*EVMS_LV_NOT_IN_LIST = *LibStoragec::EVMS_LV_NOT_IN_LIST;
*EVMS_PV_STILL_ADDED = *LibStoragec::EVMS_PV_STILL_ADDED;
*EVMS_PV_REMOVE_NOT_FOUND = *LibStoragec::EVMS_PV_REMOVE_NOT_FOUND;
*EVMS_CREATE_LV_INVALID_VOLUME = *LibStoragec::EVMS_CREATE_LV_INVALID_VOLUME;
*EVMS_REMOVE_LV_INVALID_VOLUME = *LibStoragec::EVMS_REMOVE_LV_INVALID_VOLUME;
*EVMS_RESIZE_LV_INVALID_VOLUME = *LibStoragec::EVMS_RESIZE_LV_INVALID_VOLUME;
*EVMS_CHANGE_READONLY = *LibStoragec::EVMS_CHANGE_READONLY;
*EVMS_CHECK_RESIZE_INVALID_VOLUME = *LibStoragec::EVMS_CHECK_RESIZE_INVALID_VOLUME;
*EVMS_COMMIT_NOTHING_TODO = *LibStoragec::EVMS_COMMIT_NOTHING_TODO;
*EVMS_LV_REMOVE_USED_BY = *LibStoragec::EVMS_LV_REMOVE_USED_BY;
*EVMS_COMMUNICATION_FAILED = *LibStoragec::EVMS_COMMUNICATION_FAILED;
*EVMS_LV_ALREADY_ON_DISK = *LibStoragec::EVMS_LV_ALREADY_ON_DISK;
*EVMS_LV_NO_STRIPE_SIZE = *LibStoragec::EVMS_LV_NO_STRIPE_SIZE;
*EVMS_ACTIVATE_FAILED = *LibStoragec::EVMS_ACTIVATE_FAILED;
*EVMS_CONTAINER_NOT_CREATED = *LibStoragec::EVMS_CONTAINER_NOT_CREATED;
*PEC_PE_SIZE_INVALID = *LibStoragec::PEC_PE_SIZE_INVALID;
*PEC_PV_NOT_FOUND = *LibStoragec::PEC_PV_NOT_FOUND;
*PEC_REMOVE_PV_IN_USE = *LibStoragec::PEC_REMOVE_PV_IN_USE;
*PEC_REMOVE_PV_SIZE_NEEDED = *LibStoragec::PEC_REMOVE_PV_SIZE_NEEDED;
*PEC_LV_NO_SPACE_STRIPED = *LibStoragec::PEC_LV_NO_SPACE_STRIPED;
*PEC_LV_NO_SPACE_SINGLE = *LibStoragec::PEC_LV_NO_SPACE_SINGLE;
*PEC_LV_PE_DEV_NOT_FOUND = *LibStoragec::PEC_LV_PE_DEV_NOT_FOUND;
*DM_CHANGE_READONLY = *LibStoragec::DM_CHANGE_READONLY;
*DM_UNKNOWN_TABLE = *LibStoragec::DM_UNKNOWN_TABLE;
*DM_REMOVE_USED_BY = *LibStoragec::DM_REMOVE_USED_BY;
*DM_REMOVE_CREATE_NOT_FOUND = *LibStoragec::DM_REMOVE_CREATE_NOT_FOUND;
*DM_REMOVE_INVALID_VOLUME = *LibStoragec::DM_REMOVE_INVALID_VOLUME;
*DM_REMOVE_FAILED = *LibStoragec::DM_REMOVE_FAILED;
*DM_NOT_IN_LIST = *LibStoragec::DM_NOT_IN_LIST;
*DASD_NOT_POSSIBLE = *LibStoragec::DASD_NOT_POSSIBLE;
*DASD_FDASD_FAILED = *LibStoragec::DASD_FDASD_FAILED;
*DASD_DASDFMT_FAILED = *LibStoragec::DASD_DASDFMT_FAILED;
*DMPART_CHANGE_READONLY = *LibStoragec::DMPART_CHANGE_READONLY;
*DMPART_INTERNAL_ERR = *LibStoragec::DMPART_INTERNAL_ERR;
*DMPART_INVALID_VOLUME = *LibStoragec::DMPART_INVALID_VOLUME;
*DMPART_PARTITION_NOT_FOUND = *LibStoragec::DMPART_PARTITION_NOT_FOUND;
*DMPART_REMOVE_PARTITION_LIST_ERASE = *LibStoragec::DMPART_REMOVE_PARTITION_LIST_ERASE;
*DMPART_COMMIT_NOTHING_TODO = *LibStoragec::DMPART_COMMIT_NOTHING_TODO;
*DMPART_NO_REMOVE = *LibStoragec::DMPART_NO_REMOVE;
*DMRAID_REMOVE_FAILED = *LibStoragec::DMRAID_REMOVE_FAILED;
*CONTAINER_INTERNAL_ERROR = *LibStoragec::CONTAINER_INTERNAL_ERROR;
*CONTAINER_INVALID_VIRTUAL_CALL = *LibStoragec::CONTAINER_INVALID_VIRTUAL_CALL;
1;
package LibStorage;
BEGIN {
    %TYPEINFO = (
        ALL_METHODS => 0,
        initDefaultLogger => ["function", "void"],
        createDefaultStorageInterface => ["function", "any"],
        createStorageInterface => ["function", "any", "boolean", "boolean", "boolean"],
        destroyStorageInterface => ["function", "void", "any"],
    );
}

BEGIN{$TYPEINFO{FSUNKNOWN}=["function", "integer"]}
*FSUNKNOWN = sub { $LibStoragec::FSUNKNOWN };
BEGIN{$TYPEINFO{REISERFS}=["function", "integer"]}
*REISERFS = sub { $LibStoragec::REISERFS };
BEGIN{$TYPEINFO{EXT2}=["function", "integer"]}
*EXT2 = sub { $LibStoragec::EXT2 };
BEGIN{$TYPEINFO{EXT3}=["function", "integer"]}
*EXT3 = sub { $LibStoragec::EXT3 };
BEGIN{$TYPEINFO{VFAT}=["function", "integer"]}
*VFAT = sub { $LibStoragec::VFAT };
BEGIN{$TYPEINFO{XFS}=["function", "integer"]}
*XFS = sub { $LibStoragec::XFS };
BEGIN{$TYPEINFO{JFS}=["function", "integer"]}
*JFS = sub { $LibStoragec::JFS };
BEGIN{$TYPEINFO{HFS}=["function", "integer"]}
*HFS = sub { $LibStoragec::HFS };
BEGIN{$TYPEINFO{NTFS}=["function", "integer"]}
*NTFS = sub { $LibStoragec::NTFS };
BEGIN{$TYPEINFO{SWAP}=["function", "integer"]}
*SWAP = sub { $LibStoragec::SWAP };
BEGIN{$TYPEINFO{FSNONE}=["function", "integer"]}
*FSNONE = sub { $LibStoragec::FSNONE };

BEGIN{$TYPEINFO{PRIMARY}=["function", "integer"]}
*PRIMARY = sub { $LibStoragec::PRIMARY };
BEGIN{$TYPEINFO{EXTENDED}=["function", "integer"]}
*EXTENDED = sub { $LibStoragec::EXTENDED };
BEGIN{$TYPEINFO{LOGICAL}=["function", "integer"]}
*LOGICAL = sub { $LibStoragec::LOGICAL };
BEGIN{$TYPEINFO{PTYPE_ANY}=["function", "integer"]}
*PTYPE_ANY = sub { $LibStoragec::PTYPE_ANY };

BEGIN{$TYPEINFO{MOUNTBY_DEVICE}=["function", "integer"]}
*MOUNTBY_DEVICE = sub { $LibStoragec::MOUNTBY_DEVICE };
BEGIN{$TYPEINFO{MOUNTBY_UUID}=["function", "integer"]}
*MOUNTBY_UUID = sub { $LibStoragec::MOUNTBY_UUID };
BEGIN{$TYPEINFO{MOUNTBY_LABEL}=["function", "integer"]}
*MOUNTBY_LABEL = sub { $LibStoragec::MOUNTBY_LABEL };
BEGIN{$TYPEINFO{MOUNTBY_ID}=["function", "integer"]}
*MOUNTBY_ID = sub { $LibStoragec::MOUNTBY_ID };
BEGIN{$TYPEINFO{MOUNTBY_PATH}=["function", "integer"]}
*MOUNTBY_PATH = sub { $LibStoragec::MOUNTBY_PATH };

BEGIN{$TYPEINFO{ENC_NONE}=["function", "integer"]}
*ENC_NONE = sub { $LibStoragec::ENC_NONE };
BEGIN{$TYPEINFO{ENC_TWOFISH}=["function", "integer"]}
*ENC_TWOFISH = sub { $LibStoragec::ENC_TWOFISH };
BEGIN{$TYPEINFO{ENC_TWOFISH_OLD}=["function", "integer"]}
*ENC_TWOFISH_OLD = sub { $LibStoragec::ENC_TWOFISH_OLD };
BEGIN{$TYPEINFO{ENC_TWOFISH256_OLD}=["function", "integer"]}
*ENC_TWOFISH256_OLD = sub { $LibStoragec::ENC_TWOFISH256_OLD };
BEGIN{$TYPEINFO{ENC_UNKNOWN}=["function", "integer"]}
*ENC_UNKNOWN = sub { $LibStoragec::ENC_UNKNOWN };

BEGIN{$TYPEINFO{RAID_UNK}=["function", "integer"]}
*RAID_UNK = sub { $LibStoragec::RAID_UNK };
BEGIN{$TYPEINFO{RAID0}=["function", "integer"]}
*RAID0 = sub { $LibStoragec::RAID0 };
BEGIN{$TYPEINFO{RAID1}=["function", "integer"]}
*RAID1 = sub { $LibStoragec::RAID1 };
BEGIN{$TYPEINFO{RAID5}=["function", "integer"]}
*RAID5 = sub { $LibStoragec::RAID5 };
BEGIN{$TYPEINFO{RAID6}=["function", "integer"]}
*RAID6 = sub { $LibStoragec::RAID6 };
BEGIN{$TYPEINFO{RAID10}=["function", "integer"]}
*RAID10 = sub { $LibStoragec::RAID10 };
BEGIN{$TYPEINFO{MULTIPATH}=["function", "integer"]}
*MULTIPATH = sub { $LibStoragec::MULTIPATH };

BEGIN{$TYPEINFO{PAR_NONE}=["function", "integer"]}
*PAR_NONE = sub { $LibStoragec::PAR_NONE };
BEGIN{$TYPEINFO{LEFT_ASYMMETRIC}=["function", "integer"]}
*LEFT_ASYMMETRIC = sub { $LibStoragec::LEFT_ASYMMETRIC };
BEGIN{$TYPEINFO{LEFT_SYMMETRIC}=["function", "integer"]}
*LEFT_SYMMETRIC = sub { $LibStoragec::LEFT_SYMMETRIC };
BEGIN{$TYPEINFO{RIGHT_ASYMMETRIC}=["function", "integer"]}
*RIGHT_ASYMMETRIC = sub { $LibStoragec::RIGHT_ASYMMETRIC };
BEGIN{$TYPEINFO{RIGHT_SYMMETRIC}=["function", "integer"]}
*RIGHT_SYMMETRIC = sub { $LibStoragec::RIGHT_SYMMETRIC };

BEGIN{$TYPEINFO{UB_NONE}=["function", "integer"]}
*UB_NONE = sub { $LibStoragec::UB_NONE };
BEGIN{$TYPEINFO{UB_LVM}=["function", "integer"]}
*UB_LVM = sub { $LibStoragec::UB_LVM };
BEGIN{$TYPEINFO{UB_MD}=["function", "integer"]}
*UB_MD = sub { $LibStoragec::UB_MD };
BEGIN{$TYPEINFO{UB_EVMS}=["function", "integer"]}
*UB_EVMS = sub { $LibStoragec::UB_EVMS };
BEGIN{$TYPEINFO{UB_DM}=["function", "integer"]}
*UB_DM = sub { $LibStoragec::UB_DM };
BEGIN{$TYPEINFO{UB_DMRAID}=["function", "integer"]}
*UB_DMRAID = sub { $LibStoragec::UB_DMRAID };

BEGIN{$TYPEINFO{CUNKNOWN}=["function", "integer"]}
*CUNKNOWN = sub { $LibStoragec::CUNKNOWN };
BEGIN{$TYPEINFO{DISK}=["function", "integer"]}
*DISK = sub { $LibStoragec::DISK };
BEGIN{$TYPEINFO{MD}=["function", "integer"]}
*MD = sub { $LibStoragec::MD };
BEGIN{$TYPEINFO{LOOP}=["function", "integer"]}
*LOOP = sub { $LibStoragec::LOOP };
BEGIN{$TYPEINFO{LVM}=["function", "integer"]}
*LVM = sub { $LibStoragec::LVM };
BEGIN{$TYPEINFO{DM}=["function", "integer"]}
*DM = sub { $LibStoragec::DM };
BEGIN{$TYPEINFO{EVMS}=["function", "integer"]}
*EVMS = sub { $LibStoragec::EVMS };
BEGIN{$TYPEINFO{DMRAID}=["function", "integer"]}
*DMRAID = sub { $LibStoragec::DMRAID };
BEGIN{$TYPEINFO{COTYPE_LAST_ENTRY}=["function", "integer"]}
*COTYPE_LAST_ENTRY = sub { $LibStoragec::COTYPE_LAST_ENTRY };

BEGIN{$TYPEINFO{DISK_PARTITION_OVERLAPS_EXISTING}=["function", "integer"]}
*DISK_PARTITION_OVERLAPS_EXISTING = sub { $LibStoragec::DISK_PARTITION_OVERLAPS_EXISTING };
BEGIN{$TYPEINFO{DISK_PARTITION_EXCEEDS_DISK}=["function", "integer"]}
*DISK_PARTITION_EXCEEDS_DISK = sub { $LibStoragec::DISK_PARTITION_EXCEEDS_DISK };
BEGIN{$TYPEINFO{DISK_CREATE_PARTITION_EXT_ONLY_ONCE}=["function", "integer"]}
*DISK_CREATE_PARTITION_EXT_ONLY_ONCE = sub { $LibStoragec::DISK_CREATE_PARTITION_EXT_ONLY_ONCE };
BEGIN{$TYPEINFO{DISK_CREATE_PARTITION_EXT_IMPOSSIBLE}=["function", "integer"]}
*DISK_CREATE_PARTITION_EXT_IMPOSSIBLE = sub { $LibStoragec::DISK_CREATE_PARTITION_EXT_IMPOSSIBLE };
BEGIN{$TYPEINFO{DISK_PARTITION_NO_FREE_NUMBER}=["function", "integer"]}
*DISK_PARTITION_NO_FREE_NUMBER = sub { $LibStoragec::DISK_PARTITION_NO_FREE_NUMBER };
BEGIN{$TYPEINFO{DISK_CREATE_PARTITION_INVALID_VOLUME}=["function", "integer"]}
*DISK_CREATE_PARTITION_INVALID_VOLUME = sub { $LibStoragec::DISK_CREATE_PARTITION_INVALID_VOLUME };
BEGIN{$TYPEINFO{DISK_CREATE_PARTITION_INVALID_TYPE}=["function", "integer"]}
*DISK_CREATE_PARTITION_INVALID_TYPE = sub { $LibStoragec::DISK_CREATE_PARTITION_INVALID_TYPE };
BEGIN{$TYPEINFO{DISK_CREATE_PARTITION_PARTED_FAILED}=["function", "integer"]}
*DISK_CREATE_PARTITION_PARTED_FAILED = sub { $LibStoragec::DISK_CREATE_PARTITION_PARTED_FAILED };
BEGIN{$TYPEINFO{DISK_PARTITION_NOT_FOUND}=["function", "integer"]}
*DISK_PARTITION_NOT_FOUND = sub { $LibStoragec::DISK_PARTITION_NOT_FOUND };
BEGIN{$TYPEINFO{DISK_CREATE_PARTITION_LOGICAL_NO_EXT}=["function", "integer"]}
*DISK_CREATE_PARTITION_LOGICAL_NO_EXT = sub { $LibStoragec::DISK_CREATE_PARTITION_LOGICAL_NO_EXT };
BEGIN{$TYPEINFO{DISK_PARTITION_LOGICAL_OUTSIDE_EXT}=["function", "integer"]}
*DISK_PARTITION_LOGICAL_OUTSIDE_EXT = sub { $LibStoragec::DISK_PARTITION_LOGICAL_OUTSIDE_EXT };
BEGIN{$TYPEINFO{DISK_SET_TYPE_INVALID_VOLUME}=["function", "integer"]}
*DISK_SET_TYPE_INVALID_VOLUME = sub { $LibStoragec::DISK_SET_TYPE_INVALID_VOLUME };
BEGIN{$TYPEINFO{DISK_SET_TYPE_PARTED_FAILED}=["function", "integer"]}
*DISK_SET_TYPE_PARTED_FAILED = sub { $LibStoragec::DISK_SET_TYPE_PARTED_FAILED };
BEGIN{$TYPEINFO{DISK_SET_LABEL_PARTED_FAILED}=["function", "integer"]}
*DISK_SET_LABEL_PARTED_FAILED = sub { $LibStoragec::DISK_SET_LABEL_PARTED_FAILED };
BEGIN{$TYPEINFO{DISK_REMOVE_PARTITION_PARTED_FAILED}=["function", "integer"]}
*DISK_REMOVE_PARTITION_PARTED_FAILED = sub { $LibStoragec::DISK_REMOVE_PARTITION_PARTED_FAILED };
BEGIN{$TYPEINFO{DISK_REMOVE_PARTITION_INVALID_VOLUME}=["function", "integer"]}
*DISK_REMOVE_PARTITION_INVALID_VOLUME = sub { $LibStoragec::DISK_REMOVE_PARTITION_INVALID_VOLUME };
BEGIN{$TYPEINFO{DISK_REMOVE_PARTITION_LIST_ERASE}=["function", "integer"]}
*DISK_REMOVE_PARTITION_LIST_ERASE = sub { $LibStoragec::DISK_REMOVE_PARTITION_LIST_ERASE };
BEGIN{$TYPEINFO{DISK_DESTROY_TABLE_INVALID_LABEL}=["function", "integer"]}
*DISK_DESTROY_TABLE_INVALID_LABEL = sub { $LibStoragec::DISK_DESTROY_TABLE_INVALID_LABEL };
BEGIN{$TYPEINFO{DISK_PARTITION_ZERO_SIZE}=["function", "integer"]}
*DISK_PARTITION_ZERO_SIZE = sub { $LibStoragec::DISK_PARTITION_ZERO_SIZE };
BEGIN{$TYPEINFO{DISK_CHANGE_READONLY}=["function", "integer"]}
*DISK_CHANGE_READONLY = sub { $LibStoragec::DISK_CHANGE_READONLY };
BEGIN{$TYPEINFO{DISK_RESIZE_PARTITION_INVALID_VOLUME}=["function", "integer"]}
*DISK_RESIZE_PARTITION_INVALID_VOLUME = sub { $LibStoragec::DISK_RESIZE_PARTITION_INVALID_VOLUME };
BEGIN{$TYPEINFO{DISK_RESIZE_PARTITION_PARTED_FAILED}=["function", "integer"]}
*DISK_RESIZE_PARTITION_PARTED_FAILED = sub { $LibStoragec::DISK_RESIZE_PARTITION_PARTED_FAILED };
BEGIN{$TYPEINFO{DISK_RESIZE_NO_SPACE}=["function", "integer"]}
*DISK_RESIZE_NO_SPACE = sub { $LibStoragec::DISK_RESIZE_NO_SPACE };
BEGIN{$TYPEINFO{DISK_CHECK_RESIZE_INVALID_VOLUME}=["function", "integer"]}
*DISK_CHECK_RESIZE_INVALID_VOLUME = sub { $LibStoragec::DISK_CHECK_RESIZE_INVALID_VOLUME };
BEGIN{$TYPEINFO{DISK_REMOVE_PARTITION_CREATE_NOT_FOUND}=["function", "integer"]}
*DISK_REMOVE_PARTITION_CREATE_NOT_FOUND = sub { $LibStoragec::DISK_REMOVE_PARTITION_CREATE_NOT_FOUND };
BEGIN{$TYPEINFO{DISK_COMMIT_NOTHING_TODO}=["function", "integer"]}
*DISK_COMMIT_NOTHING_TODO = sub { $LibStoragec::DISK_COMMIT_NOTHING_TODO };
BEGIN{$TYPEINFO{DISK_CREATE_PARTITION_NO_SPACE}=["function", "integer"]}
*DISK_CREATE_PARTITION_NO_SPACE = sub { $LibStoragec::DISK_CREATE_PARTITION_NO_SPACE };
BEGIN{$TYPEINFO{DISK_REMOVE_USED_BY}=["function", "integer"]}
*DISK_REMOVE_USED_BY = sub { $LibStoragec::DISK_REMOVE_USED_BY };
BEGIN{$TYPEINFO{DISK_INIT_NOT_POSSIBLE}=["function", "integer"]}
*DISK_INIT_NOT_POSSIBLE = sub { $LibStoragec::DISK_INIT_NOT_POSSIBLE };
BEGIN{$TYPEINFO{STORAGE_DISK_NOT_FOUND}=["function", "integer"]}
*STORAGE_DISK_NOT_FOUND = sub { $LibStoragec::STORAGE_DISK_NOT_FOUND };
BEGIN{$TYPEINFO{STORAGE_VOLUME_NOT_FOUND}=["function", "integer"]}
*STORAGE_VOLUME_NOT_FOUND = sub { $LibStoragec::STORAGE_VOLUME_NOT_FOUND };
BEGIN{$TYPEINFO{STORAGE_REMOVE_PARTITION_INVALID_CONTAINER}=["function", "integer"]}
*STORAGE_REMOVE_PARTITION_INVALID_CONTAINER = sub { $LibStoragec::STORAGE_REMOVE_PARTITION_INVALID_CONTAINER };
BEGIN{$TYPEINFO{STORAGE_CHANGE_PARTITION_ID_INVALID_CONTAINER}=["function", "integer"]}
*STORAGE_CHANGE_PARTITION_ID_INVALID_CONTAINER = sub { $LibStoragec::STORAGE_CHANGE_PARTITION_ID_INVALID_CONTAINER };
BEGIN{$TYPEINFO{STORAGE_CHANGE_READONLY}=["function", "integer"]}
*STORAGE_CHANGE_READONLY = sub { $LibStoragec::STORAGE_CHANGE_READONLY };
BEGIN{$TYPEINFO{STORAGE_DISK_USED_BY}=["function", "integer"]}
*STORAGE_DISK_USED_BY = sub { $LibStoragec::STORAGE_DISK_USED_BY };
BEGIN{$TYPEINFO{STORAGE_LVM_VG_EXISTS}=["function", "integer"]}
*STORAGE_LVM_VG_EXISTS = sub { $LibStoragec::STORAGE_LVM_VG_EXISTS };
BEGIN{$TYPEINFO{STORAGE_LVM_VG_NOT_FOUND}=["function", "integer"]}
*STORAGE_LVM_VG_NOT_FOUND = sub { $LibStoragec::STORAGE_LVM_VG_NOT_FOUND };
BEGIN{$TYPEINFO{STORAGE_LVM_INVALID_DEVICE}=["function", "integer"]}
*STORAGE_LVM_INVALID_DEVICE = sub { $LibStoragec::STORAGE_LVM_INVALID_DEVICE };
BEGIN{$TYPEINFO{STORAGE_CONTAINER_NOT_FOUND}=["function", "integer"]}
*STORAGE_CONTAINER_NOT_FOUND = sub { $LibStoragec::STORAGE_CONTAINER_NOT_FOUND };
BEGIN{$TYPEINFO{STORAGE_VG_INVALID_NAME}=["function", "integer"]}
*STORAGE_VG_INVALID_NAME = sub { $LibStoragec::STORAGE_VG_INVALID_NAME };
BEGIN{$TYPEINFO{STORAGE_REMOVE_USED_VOLUME}=["function", "integer"]}
*STORAGE_REMOVE_USED_VOLUME = sub { $LibStoragec::STORAGE_REMOVE_USED_VOLUME };
BEGIN{$TYPEINFO{STORAGE_REMOVE_USING_UNKNOWN_TYPE}=["function", "integer"]}
*STORAGE_REMOVE_USING_UNKNOWN_TYPE = sub { $LibStoragec::STORAGE_REMOVE_USING_UNKNOWN_TYPE };
BEGIN{$TYPEINFO{STORAGE_NOT_YET_IMPLEMENTED}=["function", "integer"]}
*STORAGE_NOT_YET_IMPLEMENTED = sub { $LibStoragec::STORAGE_NOT_YET_IMPLEMENTED };
BEGIN{$TYPEINFO{STORAGE_MD_INVALID_NAME}=["function", "integer"]}
*STORAGE_MD_INVALID_NAME = sub { $LibStoragec::STORAGE_MD_INVALID_NAME };
BEGIN{$TYPEINFO{STORAGE_MD_NOT_FOUND}=["function", "integer"]}
*STORAGE_MD_NOT_FOUND = sub { $LibStoragec::STORAGE_MD_NOT_FOUND };
BEGIN{$TYPEINFO{STORAGE_MEMORY_EXHAUSTED}=["function", "integer"]}
*STORAGE_MEMORY_EXHAUSTED = sub { $LibStoragec::STORAGE_MEMORY_EXHAUSTED };
BEGIN{$TYPEINFO{STORAGE_LOOP_NOT_FOUND}=["function", "integer"]}
*STORAGE_LOOP_NOT_FOUND = sub { $LibStoragec::STORAGE_LOOP_NOT_FOUND };
BEGIN{$TYPEINFO{STORAGE_CREATED_LOOP_NOT_FOUND}=["function", "integer"]}
*STORAGE_CREATED_LOOP_NOT_FOUND = sub { $LibStoragec::STORAGE_CREATED_LOOP_NOT_FOUND };
BEGIN{$TYPEINFO{STORAGE_EVMS_INVALID_NAME}=["function", "integer"]}
*STORAGE_EVMS_INVALID_NAME = sub { $LibStoragec::STORAGE_EVMS_INVALID_NAME };
BEGIN{$TYPEINFO{STORAGE_EVMS_CO_EXISTS}=["function", "integer"]}
*STORAGE_EVMS_CO_EXISTS = sub { $LibStoragec::STORAGE_EVMS_CO_EXISTS };
BEGIN{$TYPEINFO{STORAGE_EVMS_CO_NOT_FOUND}=["function", "integer"]}
*STORAGE_EVMS_CO_NOT_FOUND = sub { $LibStoragec::STORAGE_EVMS_CO_NOT_FOUND };
BEGIN{$TYPEINFO{STORAGE_EVMS_INVALID_DEVICE}=["function", "integer"]}
*STORAGE_EVMS_INVALID_DEVICE = sub { $LibStoragec::STORAGE_EVMS_INVALID_DEVICE };
BEGIN{$TYPEINFO{STORAGE_CHANGE_AREA_INVALID_CONTAINER}=["function", "integer"]}
*STORAGE_CHANGE_AREA_INVALID_CONTAINER = sub { $LibStoragec::STORAGE_CHANGE_AREA_INVALID_CONTAINER };
BEGIN{$TYPEINFO{STORAGE_BACKUP_STATE_NOT_FOUND}=["function", "integer"]}
*STORAGE_BACKUP_STATE_NOT_FOUND = sub { $LibStoragec::STORAGE_BACKUP_STATE_NOT_FOUND };
BEGIN{$TYPEINFO{STORAGE_INVALID_FSTAB_VALUE}=["function", "integer"]}
*STORAGE_INVALID_FSTAB_VALUE = sub { $LibStoragec::STORAGE_INVALID_FSTAB_VALUE };
BEGIN{$TYPEINFO{STORAGE_NO_FSTAB_PTR}=["function", "integer"]}
*STORAGE_NO_FSTAB_PTR = sub { $LibStoragec::STORAGE_NO_FSTAB_PTR };
BEGIN{$TYPEINFO{STORAGE_DEVICE_NODE_NOT_FOUND}=["function", "integer"]}
*STORAGE_DEVICE_NODE_NOT_FOUND = sub { $LibStoragec::STORAGE_DEVICE_NODE_NOT_FOUND };
BEGIN{$TYPEINFO{STORAGE_DMRAID_CO_NOT_FOUND}=["function", "integer"]}
*STORAGE_DMRAID_CO_NOT_FOUND = sub { $LibStoragec::STORAGE_DMRAID_CO_NOT_FOUND };
BEGIN{$TYPEINFO{STORAGE_RESIZE_INVALID_CONTAINER}=["function", "integer"]}
*STORAGE_RESIZE_INVALID_CONTAINER = sub { $LibStoragec::STORAGE_RESIZE_INVALID_CONTAINER };
BEGIN{$TYPEINFO{VOLUME_COMMIT_UNKNOWN_STAGE}=["function", "integer"]}
*VOLUME_COMMIT_UNKNOWN_STAGE = sub { $LibStoragec::VOLUME_COMMIT_UNKNOWN_STAGE };
BEGIN{$TYPEINFO{VOLUME_FSTAB_EMPTY_MOUNT}=["function", "integer"]}
*VOLUME_FSTAB_EMPTY_MOUNT = sub { $LibStoragec::VOLUME_FSTAB_EMPTY_MOUNT };
BEGIN{$TYPEINFO{VOLUME_UMOUNT_FAILED}=["function", "integer"]}
*VOLUME_UMOUNT_FAILED = sub { $LibStoragec::VOLUME_UMOUNT_FAILED };
BEGIN{$TYPEINFO{VOLUME_MOUNT_FAILED}=["function", "integer"]}
*VOLUME_MOUNT_FAILED = sub { $LibStoragec::VOLUME_MOUNT_FAILED };
BEGIN{$TYPEINFO{VOLUME_FORMAT_DD_FAILED}=["function", "integer"]}
*VOLUME_FORMAT_DD_FAILED = sub { $LibStoragec::VOLUME_FORMAT_DD_FAILED };
BEGIN{$TYPEINFO{VOLUME_FORMAT_UNKNOWN_FS}=["function", "integer"]}
*VOLUME_FORMAT_UNKNOWN_FS = sub { $LibStoragec::VOLUME_FORMAT_UNKNOWN_FS };
BEGIN{$TYPEINFO{VOLUME_FORMAT_FS_UNDETECTED}=["function", "integer"]}
*VOLUME_FORMAT_FS_UNDETECTED = sub { $LibStoragec::VOLUME_FORMAT_FS_UNDETECTED };
BEGIN{$TYPEINFO{VOLUME_FORMAT_FS_TOO_SMALL}=["function", "integer"]}
*VOLUME_FORMAT_FS_TOO_SMALL = sub { $LibStoragec::VOLUME_FORMAT_FS_TOO_SMALL };
BEGIN{$TYPEINFO{VOLUME_FORMAT_FAILED}=["function", "integer"]}
*VOLUME_FORMAT_FAILED = sub { $LibStoragec::VOLUME_FORMAT_FAILED };
BEGIN{$TYPEINFO{VOLUME_TUNE2FS_FAILED}=["function", "integer"]}
*VOLUME_TUNE2FS_FAILED = sub { $LibStoragec::VOLUME_TUNE2FS_FAILED };
BEGIN{$TYPEINFO{VOLUME_MKLABEL_FS_UNABLE}=["function", "integer"]}
*VOLUME_MKLABEL_FS_UNABLE = sub { $LibStoragec::VOLUME_MKLABEL_FS_UNABLE };
BEGIN{$TYPEINFO{VOLUME_MKLABEL_FAILED}=["function", "integer"]}
*VOLUME_MKLABEL_FAILED = sub { $LibStoragec::VOLUME_MKLABEL_FAILED };
BEGIN{$TYPEINFO{VOLUME_LOSETUP_NO_LOOP}=["function", "integer"]}
*VOLUME_LOSETUP_NO_LOOP = sub { $LibStoragec::VOLUME_LOSETUP_NO_LOOP };
BEGIN{$TYPEINFO{VOLUME_LOSETUP_FAILED}=["function", "integer"]}
*VOLUME_LOSETUP_FAILED = sub { $LibStoragec::VOLUME_LOSETUP_FAILED };
BEGIN{$TYPEINFO{VOLUME_CRYPT_NO_PWD}=["function", "integer"]}
*VOLUME_CRYPT_NO_PWD = sub { $LibStoragec::VOLUME_CRYPT_NO_PWD };
BEGIN{$TYPEINFO{VOLUME_CRYPT_PWD_TOO_SHORT}=["function", "integer"]}
*VOLUME_CRYPT_PWD_TOO_SHORT = sub { $LibStoragec::VOLUME_CRYPT_PWD_TOO_SHORT };
BEGIN{$TYPEINFO{VOLUME_CRYPT_NOT_DETECTED}=["function", "integer"]}
*VOLUME_CRYPT_NOT_DETECTED = sub { $LibStoragec::VOLUME_CRYPT_NOT_DETECTED };
BEGIN{$TYPEINFO{VOLUME_FORMAT_EXTENDED_UNSUPPORTED}=["function", "integer"]}
*VOLUME_FORMAT_EXTENDED_UNSUPPORTED = sub { $LibStoragec::VOLUME_FORMAT_EXTENDED_UNSUPPORTED };
BEGIN{$TYPEINFO{VOLUME_MOUNT_EXTENDED_UNSUPPORTED}=["function", "integer"]}
*VOLUME_MOUNT_EXTENDED_UNSUPPORTED = sub { $LibStoragec::VOLUME_MOUNT_EXTENDED_UNSUPPORTED };
BEGIN{$TYPEINFO{VOLUME_MOUNT_POINT_INVALID}=["function", "integer"]}
*VOLUME_MOUNT_POINT_INVALID = sub { $LibStoragec::VOLUME_MOUNT_POINT_INVALID };
BEGIN{$TYPEINFO{VOLUME_MOUNTBY_NOT_ENCRYPTED}=["function", "integer"]}
*VOLUME_MOUNTBY_NOT_ENCRYPTED = sub { $LibStoragec::VOLUME_MOUNTBY_NOT_ENCRYPTED };
BEGIN{$TYPEINFO{VOLUME_MOUNTBY_UNSUPPORTED_BY_FS}=["function", "integer"]}
*VOLUME_MOUNTBY_UNSUPPORTED_BY_FS = sub { $LibStoragec::VOLUME_MOUNTBY_UNSUPPORTED_BY_FS };
BEGIN{$TYPEINFO{VOLUME_LABEL_NOT_SUPPORTED}=["function", "integer"]}
*VOLUME_LABEL_NOT_SUPPORTED = sub { $LibStoragec::VOLUME_LABEL_NOT_SUPPORTED };
BEGIN{$TYPEINFO{VOLUME_LABEL_TOO_LONG}=["function", "integer"]}
*VOLUME_LABEL_TOO_LONG = sub { $LibStoragec::VOLUME_LABEL_TOO_LONG };
BEGIN{$TYPEINFO{VOLUME_LABEL_WHILE_MOUNTED}=["function", "integer"]}
*VOLUME_LABEL_WHILE_MOUNTED = sub { $LibStoragec::VOLUME_LABEL_WHILE_MOUNTED };
BEGIN{$TYPEINFO{VOLUME_RESIZE_UNSUPPORTED_BY_FS}=["function", "integer"]}
*VOLUME_RESIZE_UNSUPPORTED_BY_FS = sub { $LibStoragec::VOLUME_RESIZE_UNSUPPORTED_BY_FS };
BEGIN{$TYPEINFO{VOLUME_RESIZE_UNSUPPORTED_BY_CONTAINER}=["function", "integer"]}
*VOLUME_RESIZE_UNSUPPORTED_BY_CONTAINER = sub { $LibStoragec::VOLUME_RESIZE_UNSUPPORTED_BY_CONTAINER };
BEGIN{$TYPEINFO{VOLUME_RESIZE_FAILED}=["function", "integer"]}
*VOLUME_RESIZE_FAILED = sub { $LibStoragec::VOLUME_RESIZE_FAILED };
BEGIN{$TYPEINFO{VOLUME_ALREADY_IN_USE}=["function", "integer"]}
*VOLUME_ALREADY_IN_USE = sub { $LibStoragec::VOLUME_ALREADY_IN_USE };
BEGIN{$TYPEINFO{VOLUME_LOUNSETUP_FAILED}=["function", "integer"]}
*VOLUME_LOUNSETUP_FAILED = sub { $LibStoragec::VOLUME_LOUNSETUP_FAILED };
BEGIN{$TYPEINFO{VOLUME_DEVICE_NOT_PRESENT}=["function", "integer"]}
*VOLUME_DEVICE_NOT_PRESENT = sub { $LibStoragec::VOLUME_DEVICE_NOT_PRESENT };
BEGIN{$TYPEINFO{VOLUME_DEVICE_NOT_BLOCK}=["function", "integer"]}
*VOLUME_DEVICE_NOT_BLOCK = sub { $LibStoragec::VOLUME_DEVICE_NOT_BLOCK };
BEGIN{$TYPEINFO{VOLUME_MOUNTBY_UNSUPPORTED_BY_VOLUME}=["function", "integer"]}
*VOLUME_MOUNTBY_UNSUPPORTED_BY_VOLUME = sub { $LibStoragec::VOLUME_MOUNTBY_UNSUPPORTED_BY_VOLUME };
BEGIN{$TYPEINFO{LVM_CREATE_PV_FAILED}=["function", "integer"]}
*LVM_CREATE_PV_FAILED = sub { $LibStoragec::LVM_CREATE_PV_FAILED };
BEGIN{$TYPEINFO{LVM_PV_ALREADY_CONTAINED}=["function", "integer"]}
*LVM_PV_ALREADY_CONTAINED = sub { $LibStoragec::LVM_PV_ALREADY_CONTAINED };
BEGIN{$TYPEINFO{LVM_PV_DEVICE_UNKNOWN}=["function", "integer"]}
*LVM_PV_DEVICE_UNKNOWN = sub { $LibStoragec::LVM_PV_DEVICE_UNKNOWN };
BEGIN{$TYPEINFO{LVM_PV_DEVICE_USED}=["function", "integer"]}
*LVM_PV_DEVICE_USED = sub { $LibStoragec::LVM_PV_DEVICE_USED };
BEGIN{$TYPEINFO{LVM_VG_HAS_NONE_PV}=["function", "integer"]}
*LVM_VG_HAS_NONE_PV = sub { $LibStoragec::LVM_VG_HAS_NONE_PV };
BEGIN{$TYPEINFO{LVM_LV_INVALID_NAME}=["function", "integer"]}
*LVM_LV_INVALID_NAME = sub { $LibStoragec::LVM_LV_INVALID_NAME };
BEGIN{$TYPEINFO{LVM_LV_DUPLICATE_NAME}=["function", "integer"]}
*LVM_LV_DUPLICATE_NAME = sub { $LibStoragec::LVM_LV_DUPLICATE_NAME };
BEGIN{$TYPEINFO{LVM_LV_NO_SPACE}=["function", "integer"]}
*LVM_LV_NO_SPACE = sub { $LibStoragec::LVM_LV_NO_SPACE };
BEGIN{$TYPEINFO{LVM_LV_UNKNOWN_NAME}=["function", "integer"]}
*LVM_LV_UNKNOWN_NAME = sub { $LibStoragec::LVM_LV_UNKNOWN_NAME };
BEGIN{$TYPEINFO{LVM_LV_NOT_IN_LIST}=["function", "integer"]}
*LVM_LV_NOT_IN_LIST = sub { $LibStoragec::LVM_LV_NOT_IN_LIST };
BEGIN{$TYPEINFO{LVM_VG_CREATE_FAILED}=["function", "integer"]}
*LVM_VG_CREATE_FAILED = sub { $LibStoragec::LVM_VG_CREATE_FAILED };
BEGIN{$TYPEINFO{LVM_VG_EXTEND_FAILED}=["function", "integer"]}
*LVM_VG_EXTEND_FAILED = sub { $LibStoragec::LVM_VG_EXTEND_FAILED };
BEGIN{$TYPEINFO{LVM_VG_REDUCE_FAILED}=["function", "integer"]}
*LVM_VG_REDUCE_FAILED = sub { $LibStoragec::LVM_VG_REDUCE_FAILED };
BEGIN{$TYPEINFO{LVM_VG_REMOVE_FAILED}=["function", "integer"]}
*LVM_VG_REMOVE_FAILED = sub { $LibStoragec::LVM_VG_REMOVE_FAILED };
BEGIN{$TYPEINFO{LVM_LV_CREATE_FAILED}=["function", "integer"]}
*LVM_LV_CREATE_FAILED = sub { $LibStoragec::LVM_LV_CREATE_FAILED };
BEGIN{$TYPEINFO{LVM_LV_REMOVE_FAILED}=["function", "integer"]}
*LVM_LV_REMOVE_FAILED = sub { $LibStoragec::LVM_LV_REMOVE_FAILED };
BEGIN{$TYPEINFO{LVM_LV_RESIZE_FAILED}=["function", "integer"]}
*LVM_LV_RESIZE_FAILED = sub { $LibStoragec::LVM_LV_RESIZE_FAILED };
BEGIN{$TYPEINFO{LVM_PV_STILL_ADDED}=["function", "integer"]}
*LVM_PV_STILL_ADDED = sub { $LibStoragec::LVM_PV_STILL_ADDED };
BEGIN{$TYPEINFO{LVM_PV_REMOVE_NOT_FOUND}=["function", "integer"]}
*LVM_PV_REMOVE_NOT_FOUND = sub { $LibStoragec::LVM_PV_REMOVE_NOT_FOUND };
BEGIN{$TYPEINFO{LVM_CREATE_LV_INVALID_VOLUME}=["function", "integer"]}
*LVM_CREATE_LV_INVALID_VOLUME = sub { $LibStoragec::LVM_CREATE_LV_INVALID_VOLUME };
BEGIN{$TYPEINFO{LVM_REMOVE_LV_INVALID_VOLUME}=["function", "integer"]}
*LVM_REMOVE_LV_INVALID_VOLUME = sub { $LibStoragec::LVM_REMOVE_LV_INVALID_VOLUME };
BEGIN{$TYPEINFO{LVM_RESIZE_LV_INVALID_VOLUME}=["function", "integer"]}
*LVM_RESIZE_LV_INVALID_VOLUME = sub { $LibStoragec::LVM_RESIZE_LV_INVALID_VOLUME };
BEGIN{$TYPEINFO{LVM_CHANGE_READONLY}=["function", "integer"]}
*LVM_CHANGE_READONLY = sub { $LibStoragec::LVM_CHANGE_READONLY };
BEGIN{$TYPEINFO{LVM_CHECK_RESIZE_INVALID_VOLUME}=["function", "integer"]}
*LVM_CHECK_RESIZE_INVALID_VOLUME = sub { $LibStoragec::LVM_CHECK_RESIZE_INVALID_VOLUME };
BEGIN{$TYPEINFO{LVM_COMMIT_NOTHING_TODO}=["function", "integer"]}
*LVM_COMMIT_NOTHING_TODO = sub { $LibStoragec::LVM_COMMIT_NOTHING_TODO };
BEGIN{$TYPEINFO{LVM_LV_REMOVE_USED_BY}=["function", "integer"]}
*LVM_LV_REMOVE_USED_BY = sub { $LibStoragec::LVM_LV_REMOVE_USED_BY };
BEGIN{$TYPEINFO{LVM_LV_ALREADY_ON_DISK}=["function", "integer"]}
*LVM_LV_ALREADY_ON_DISK = sub { $LibStoragec::LVM_LV_ALREADY_ON_DISK };
BEGIN{$TYPEINFO{LVM_LV_NO_STRIPE_SIZE}=["function", "integer"]}
*LVM_LV_NO_STRIPE_SIZE = sub { $LibStoragec::LVM_LV_NO_STRIPE_SIZE };
BEGIN{$TYPEINFO{FSTAB_ENTRY_NOT_FOUND}=["function", "integer"]}
*FSTAB_ENTRY_NOT_FOUND = sub { $LibStoragec::FSTAB_ENTRY_NOT_FOUND };
BEGIN{$TYPEINFO{FSTAB_CHANGE_PREFIX_IMPOSSIBLE}=["function", "integer"]}
*FSTAB_CHANGE_PREFIX_IMPOSSIBLE = sub { $LibStoragec::FSTAB_CHANGE_PREFIX_IMPOSSIBLE };
BEGIN{$TYPEINFO{FSTAB_REMOVE_ENTRY_NOT_FOUND}=["function", "integer"]}
*FSTAB_REMOVE_ENTRY_NOT_FOUND = sub { $LibStoragec::FSTAB_REMOVE_ENTRY_NOT_FOUND };
BEGIN{$TYPEINFO{FSTAB_UPDATE_ENTRY_NOT_FOUND}=["function", "integer"]}
*FSTAB_UPDATE_ENTRY_NOT_FOUND = sub { $LibStoragec::FSTAB_UPDATE_ENTRY_NOT_FOUND };
BEGIN{$TYPEINFO{FSTAB_ADD_ENTRY_FOUND}=["function", "integer"]}
*FSTAB_ADD_ENTRY_FOUND = sub { $LibStoragec::FSTAB_ADD_ENTRY_FOUND };
BEGIN{$TYPEINFO{MD_CHANGE_READONLY}=["function", "integer"]}
*MD_CHANGE_READONLY = sub { $LibStoragec::MD_CHANGE_READONLY };
BEGIN{$TYPEINFO{MD_DUPLICATE_NUMBER}=["function", "integer"]}
*MD_DUPLICATE_NUMBER = sub { $LibStoragec::MD_DUPLICATE_NUMBER };
BEGIN{$TYPEINFO{MD_TOO_FEW_DEVICES}=["function", "integer"]}
*MD_TOO_FEW_DEVICES = sub { $LibStoragec::MD_TOO_FEW_DEVICES };
BEGIN{$TYPEINFO{MD_DEVICE_UNKNOWN}=["function", "integer"]}
*MD_DEVICE_UNKNOWN = sub { $LibStoragec::MD_DEVICE_UNKNOWN };
BEGIN{$TYPEINFO{MD_DEVICE_USED}=["function", "integer"]}
*MD_DEVICE_USED = sub { $LibStoragec::MD_DEVICE_USED };
BEGIN{$TYPEINFO{MD_CREATE_INVALID_VOLUME}=["function", "integer"]}
*MD_CREATE_INVALID_VOLUME = sub { $LibStoragec::MD_CREATE_INVALID_VOLUME };
BEGIN{$TYPEINFO{MD_REMOVE_FAILED}=["function", "integer"]}
*MD_REMOVE_FAILED = sub { $LibStoragec::MD_REMOVE_FAILED };
BEGIN{$TYPEINFO{MD_NOT_IN_LIST}=["function", "integer"]}
*MD_NOT_IN_LIST = sub { $LibStoragec::MD_NOT_IN_LIST };
BEGIN{$TYPEINFO{MD_CREATE_FAILED}=["function", "integer"]}
*MD_CREATE_FAILED = sub { $LibStoragec::MD_CREATE_FAILED };
BEGIN{$TYPEINFO{MD_UNKNOWN_NUMBER}=["function", "integer"]}
*MD_UNKNOWN_NUMBER = sub { $LibStoragec::MD_UNKNOWN_NUMBER };
BEGIN{$TYPEINFO{MD_REMOVE_USED_BY}=["function", "integer"]}
*MD_REMOVE_USED_BY = sub { $LibStoragec::MD_REMOVE_USED_BY };
BEGIN{$TYPEINFO{MD_NUMBER_TOO_LARGE}=["function", "integer"]}
*MD_NUMBER_TOO_LARGE = sub { $LibStoragec::MD_NUMBER_TOO_LARGE };
BEGIN{$TYPEINFO{MD_REMOVE_INVALID_VOLUME}=["function", "integer"]}
*MD_REMOVE_INVALID_VOLUME = sub { $LibStoragec::MD_REMOVE_INVALID_VOLUME };
BEGIN{$TYPEINFO{MD_REMOVE_CREATE_NOT_FOUND}=["function", "integer"]}
*MD_REMOVE_CREATE_NOT_FOUND = sub { $LibStoragec::MD_REMOVE_CREATE_NOT_FOUND };
BEGIN{$TYPEINFO{MD_NO_RESIZE_ON_DISK}=["function", "integer"]}
*MD_NO_RESIZE_ON_DISK = sub { $LibStoragec::MD_NO_RESIZE_ON_DISK };
BEGIN{$TYPEINFO{MD_ADD_DUPLICATE}=["function", "integer"]}
*MD_ADD_DUPLICATE = sub { $LibStoragec::MD_ADD_DUPLICATE };
BEGIN{$TYPEINFO{MD_REMOVE_NONEXISTENT}=["function", "integer"]}
*MD_REMOVE_NONEXISTENT = sub { $LibStoragec::MD_REMOVE_NONEXISTENT };
BEGIN{$TYPEINFO{MD_NO_CHANGE_ON_DISK}=["function", "integer"]}
*MD_NO_CHANGE_ON_DISK = sub { $LibStoragec::MD_NO_CHANGE_ON_DISK };
BEGIN{$TYPEINFO{MD_NO_CREATE_UNKNOWN}=["function", "integer"]}
*MD_NO_CREATE_UNKNOWN = sub { $LibStoragec::MD_NO_CREATE_UNKNOWN };
BEGIN{$TYPEINFO{LOOP_CHANGE_READONLY}=["function", "integer"]}
*LOOP_CHANGE_READONLY = sub { $LibStoragec::LOOP_CHANGE_READONLY };
BEGIN{$TYPEINFO{LOOP_DUPLICATE_FILE}=["function", "integer"]}
*LOOP_DUPLICATE_FILE = sub { $LibStoragec::LOOP_DUPLICATE_FILE };
BEGIN{$TYPEINFO{LOOP_UNKNOWN_FILE}=["function", "integer"]}
*LOOP_UNKNOWN_FILE = sub { $LibStoragec::LOOP_UNKNOWN_FILE };
BEGIN{$TYPEINFO{LOOP_REMOVE_USED_BY}=["function", "integer"]}
*LOOP_REMOVE_USED_BY = sub { $LibStoragec::LOOP_REMOVE_USED_BY };
BEGIN{$TYPEINFO{LOOP_FILE_CREATE_FAILED}=["function", "integer"]}
*LOOP_FILE_CREATE_FAILED = sub { $LibStoragec::LOOP_FILE_CREATE_FAILED };
BEGIN{$TYPEINFO{LOOP_CREATE_INVALID_VOLUME}=["function", "integer"]}
*LOOP_CREATE_INVALID_VOLUME = sub { $LibStoragec::LOOP_CREATE_INVALID_VOLUME };
BEGIN{$TYPEINFO{LOOP_REMOVE_FILE_FAILED}=["function", "integer"]}
*LOOP_REMOVE_FILE_FAILED = sub { $LibStoragec::LOOP_REMOVE_FILE_FAILED };
BEGIN{$TYPEINFO{LOOP_REMOVE_INVALID_VOLUME}=["function", "integer"]}
*LOOP_REMOVE_INVALID_VOLUME = sub { $LibStoragec::LOOP_REMOVE_INVALID_VOLUME };
BEGIN{$TYPEINFO{LOOP_NOT_IN_LIST}=["function", "integer"]}
*LOOP_NOT_IN_LIST = sub { $LibStoragec::LOOP_NOT_IN_LIST };
BEGIN{$TYPEINFO{LOOP_REMOVE_CREATE_NOT_FOUND}=["function", "integer"]}
*LOOP_REMOVE_CREATE_NOT_FOUND = sub { $LibStoragec::LOOP_REMOVE_CREATE_NOT_FOUND };
BEGIN{$TYPEINFO{LOOP_MODIFY_EXISTING}=["function", "integer"]}
*LOOP_MODIFY_EXISTING = sub { $LibStoragec::LOOP_MODIFY_EXISTING };
BEGIN{$TYPEINFO{EVMS_HELPER_UNKNOWN_CMD}=["function", "integer"]}
*EVMS_HELPER_UNKNOWN_CMD = sub { $LibStoragec::EVMS_HELPER_UNKNOWN_CMD };
BEGIN{$TYPEINFO{EVMS_UNSUPPORTED_CONTAINER_TYPE}=["function", "integer"]}
*EVMS_UNSUPPORTED_CONTAINER_TYPE = sub { $LibStoragec::EVMS_UNSUPPORTED_CONTAINER_TYPE };
BEGIN{$TYPEINFO{EVMS_MALLOC_FAILED}=["function", "integer"]}
*EVMS_MALLOC_FAILED = sub { $LibStoragec::EVMS_MALLOC_FAILED };
BEGIN{$TYPEINFO{EVMS_INVALID_PHYSICAL_VOLUME}=["function", "integer"]}
*EVMS_INVALID_PHYSICAL_VOLUME = sub { $LibStoragec::EVMS_INVALID_PHYSICAL_VOLUME };
BEGIN{$TYPEINFO{EVMS_PHYSICAL_VOLUME_IN_USE}=["function", "integer"]}
*EVMS_PHYSICAL_VOLUME_IN_USE = sub { $LibStoragec::EVMS_PHYSICAL_VOLUME_IN_USE };
BEGIN{$TYPEINFO{EVMS_PLUGIN_NOT_FOUND}=["function", "integer"]}
*EVMS_PLUGIN_NOT_FOUND = sub { $LibStoragec::EVMS_PLUGIN_NOT_FOUND };
BEGIN{$TYPEINFO{EVMS_CREATE_CONTAINER_FAILED}=["function", "integer"]}
*EVMS_CREATE_CONTAINER_FAILED = sub { $LibStoragec::EVMS_CREATE_CONTAINER_FAILED };
BEGIN{$TYPEINFO{EVMS_RESIZE_VOLUME_NOT_FOUND}=["function", "integer"]}
*EVMS_RESIZE_VOLUME_NOT_FOUND = sub { $LibStoragec::EVMS_RESIZE_VOLUME_NOT_FOUND };
BEGIN{$TYPEINFO{EVMS_RESIZE_CONTAINER_NOT_FOUND}=["function", "integer"]}
*EVMS_RESIZE_CONTAINER_NOT_FOUND = sub { $LibStoragec::EVMS_RESIZE_CONTAINER_NOT_FOUND };
BEGIN{$TYPEINFO{EVMS_RESIZE_EXPAND_FAILED}=["function", "integer"]}
*EVMS_RESIZE_EXPAND_FAILED = sub { $LibStoragec::EVMS_RESIZE_EXPAND_FAILED };
BEGIN{$TYPEINFO{EVMS_RESIZE_SHRINK_FAILED}=["function", "integer"]}
*EVMS_RESIZE_SHRINK_FAILED = sub { $LibStoragec::EVMS_RESIZE_SHRINK_FAILED };
BEGIN{$TYPEINFO{EVMS_COMMIT_FAILED}=["function", "integer"]}
*EVMS_COMMIT_FAILED = sub { $LibStoragec::EVMS_COMMIT_FAILED };
BEGIN{$TYPEINFO{EVMS_CREATE_VOLUME_FREESPACE_NOT_FOUND}=["function", "integer"]}
*EVMS_CREATE_VOLUME_FREESPACE_NOT_FOUND = sub { $LibStoragec::EVMS_CREATE_VOLUME_FREESPACE_NOT_FOUND };
BEGIN{$TYPEINFO{EVMS_CREATE_VOLUME_FAILED}=["function", "integer"]}
*EVMS_CREATE_VOLUME_FAILED = sub { $LibStoragec::EVMS_CREATE_VOLUME_FAILED };
BEGIN{$TYPEINFO{EVMS_CREATE_COMPAT_VOLUME_FAILED}=["function", "integer"]}
*EVMS_CREATE_COMPAT_VOLUME_FAILED = sub { $LibStoragec::EVMS_CREATE_COMPAT_VOLUME_FAILED };
BEGIN{$TYPEINFO{EVMS_SEGMENT_NOT_FOUND}=["function", "integer"]}
*EVMS_SEGMENT_NOT_FOUND = sub { $LibStoragec::EVMS_SEGMENT_NOT_FOUND };
BEGIN{$TYPEINFO{EVMS_REMOVE_VOLUME_NOT_FOUND}=["function", "integer"]}
*EVMS_REMOVE_VOLUME_NOT_FOUND = sub { $LibStoragec::EVMS_REMOVE_VOLUME_NOT_FOUND };
BEGIN{$TYPEINFO{EVMS_REMOVE_REGION_FAILED}=["function", "integer"]}
*EVMS_REMOVE_REGION_FAILED = sub { $LibStoragec::EVMS_REMOVE_REGION_FAILED };
BEGIN{$TYPEINFO{EVMS_CONTAINER_NOT_FOUND}=["function", "integer"]}
*EVMS_CONTAINER_NOT_FOUND = sub { $LibStoragec::EVMS_CONTAINER_NOT_FOUND };
BEGIN{$TYPEINFO{EVMS_CONTAINER_EXPAND_FAILED}=["function", "integer"]}
*EVMS_CONTAINER_EXPAND_FAILED = sub { $LibStoragec::EVMS_CONTAINER_EXPAND_FAILED };
BEGIN{$TYPEINFO{EVMS_CONTAINER_SHRINK_INVALID_SEGMENT}=["function", "integer"]}
*EVMS_CONTAINER_SHRINK_INVALID_SEGMENT = sub { $LibStoragec::EVMS_CONTAINER_SHRINK_INVALID_SEGMENT };
BEGIN{$TYPEINFO{EVMS_CONTAINER_SHRINK_FAILED}=["function", "integer"]}
*EVMS_CONTAINER_SHRINK_FAILED = sub { $LibStoragec::EVMS_CONTAINER_SHRINK_FAILED };
BEGIN{$TYPEINFO{EVMS_CONTAINER_REMOVE_FAILED}=["function", "integer"]}
*EVMS_CONTAINER_REMOVE_FAILED = sub { $LibStoragec::EVMS_CONTAINER_REMOVE_FAILED };
BEGIN{$TYPEINFO{EVMS_PV_ALREADY_CONTAINED}=["function", "integer"]}
*EVMS_PV_ALREADY_CONTAINED = sub { $LibStoragec::EVMS_PV_ALREADY_CONTAINED };
BEGIN{$TYPEINFO{EVMS_PV_DEVICE_UNKNOWN}=["function", "integer"]}
*EVMS_PV_DEVICE_UNKNOWN = sub { $LibStoragec::EVMS_PV_DEVICE_UNKNOWN };
BEGIN{$TYPEINFO{EVMS_PV_DEVICE_USED}=["function", "integer"]}
*EVMS_PV_DEVICE_USED = sub { $LibStoragec::EVMS_PV_DEVICE_USED };
BEGIN{$TYPEINFO{EVMS_CO_HAS_NONE_PV}=["function", "integer"]}
*EVMS_CO_HAS_NONE_PV = sub { $LibStoragec::EVMS_CO_HAS_NONE_PV };
BEGIN{$TYPEINFO{EVMS_LV_INVALID_NAME}=["function", "integer"]}
*EVMS_LV_INVALID_NAME = sub { $LibStoragec::EVMS_LV_INVALID_NAME };
BEGIN{$TYPEINFO{EVMS_LV_DUPLICATE_NAME}=["function", "integer"]}
*EVMS_LV_DUPLICATE_NAME = sub { $LibStoragec::EVMS_LV_DUPLICATE_NAME };
BEGIN{$TYPEINFO{EVMS_LV_NO_SPACE}=["function", "integer"]}
*EVMS_LV_NO_SPACE = sub { $LibStoragec::EVMS_LV_NO_SPACE };
BEGIN{$TYPEINFO{EVMS_LV_UNKNOWN_NAME}=["function", "integer"]}
*EVMS_LV_UNKNOWN_NAME = sub { $LibStoragec::EVMS_LV_UNKNOWN_NAME };
BEGIN{$TYPEINFO{EVMS_LV_NOT_IN_LIST}=["function", "integer"]}
*EVMS_LV_NOT_IN_LIST = sub { $LibStoragec::EVMS_LV_NOT_IN_LIST };
BEGIN{$TYPEINFO{EVMS_PV_STILL_ADDED}=["function", "integer"]}
*EVMS_PV_STILL_ADDED = sub { $LibStoragec::EVMS_PV_STILL_ADDED };
BEGIN{$TYPEINFO{EVMS_PV_REMOVE_NOT_FOUND}=["function", "integer"]}
*EVMS_PV_REMOVE_NOT_FOUND = sub { $LibStoragec::EVMS_PV_REMOVE_NOT_FOUND };
BEGIN{$TYPEINFO{EVMS_CREATE_LV_INVALID_VOLUME}=["function", "integer"]}
*EVMS_CREATE_LV_INVALID_VOLUME = sub { $LibStoragec::EVMS_CREATE_LV_INVALID_VOLUME };
BEGIN{$TYPEINFO{EVMS_REMOVE_LV_INVALID_VOLUME}=["function", "integer"]}
*EVMS_REMOVE_LV_INVALID_VOLUME = sub { $LibStoragec::EVMS_REMOVE_LV_INVALID_VOLUME };
BEGIN{$TYPEINFO{EVMS_RESIZE_LV_INVALID_VOLUME}=["function", "integer"]}
*EVMS_RESIZE_LV_INVALID_VOLUME = sub { $LibStoragec::EVMS_RESIZE_LV_INVALID_VOLUME };
BEGIN{$TYPEINFO{EVMS_CHANGE_READONLY}=["function", "integer"]}
*EVMS_CHANGE_READONLY = sub { $LibStoragec::EVMS_CHANGE_READONLY };
BEGIN{$TYPEINFO{EVMS_CHECK_RESIZE_INVALID_VOLUME}=["function", "integer"]}
*EVMS_CHECK_RESIZE_INVALID_VOLUME = sub { $LibStoragec::EVMS_CHECK_RESIZE_INVALID_VOLUME };
BEGIN{$TYPEINFO{EVMS_COMMIT_NOTHING_TODO}=["function", "integer"]}
*EVMS_COMMIT_NOTHING_TODO = sub { $LibStoragec::EVMS_COMMIT_NOTHING_TODO };
BEGIN{$TYPEINFO{EVMS_LV_REMOVE_USED_BY}=["function", "integer"]}
*EVMS_LV_REMOVE_USED_BY = sub { $LibStoragec::EVMS_LV_REMOVE_USED_BY };
BEGIN{$TYPEINFO{EVMS_COMMUNICATION_FAILED}=["function", "integer"]}
*EVMS_COMMUNICATION_FAILED = sub { $LibStoragec::EVMS_COMMUNICATION_FAILED };
BEGIN{$TYPEINFO{EVMS_LV_ALREADY_ON_DISK}=["function", "integer"]}
*EVMS_LV_ALREADY_ON_DISK = sub { $LibStoragec::EVMS_LV_ALREADY_ON_DISK };
BEGIN{$TYPEINFO{EVMS_LV_NO_STRIPE_SIZE}=["function", "integer"]}
*EVMS_LV_NO_STRIPE_SIZE = sub { $LibStoragec::EVMS_LV_NO_STRIPE_SIZE };
BEGIN{$TYPEINFO{EVMS_ACTIVATE_FAILED}=["function", "integer"]}
*EVMS_ACTIVATE_FAILED = sub { $LibStoragec::EVMS_ACTIVATE_FAILED };
BEGIN{$TYPEINFO{EVMS_CONTAINER_NOT_CREATED}=["function", "integer"]}
*EVMS_CONTAINER_NOT_CREATED = sub { $LibStoragec::EVMS_CONTAINER_NOT_CREATED };
BEGIN{$TYPEINFO{PEC_PE_SIZE_INVALID}=["function", "integer"]}
*PEC_PE_SIZE_INVALID = sub { $LibStoragec::PEC_PE_SIZE_INVALID };
BEGIN{$TYPEINFO{PEC_PV_NOT_FOUND}=["function", "integer"]}
*PEC_PV_NOT_FOUND = sub { $LibStoragec::PEC_PV_NOT_FOUND };
BEGIN{$TYPEINFO{PEC_REMOVE_PV_IN_USE}=["function", "integer"]}
*PEC_REMOVE_PV_IN_USE = sub { $LibStoragec::PEC_REMOVE_PV_IN_USE };
BEGIN{$TYPEINFO{PEC_REMOVE_PV_SIZE_NEEDED}=["function", "integer"]}
*PEC_REMOVE_PV_SIZE_NEEDED = sub { $LibStoragec::PEC_REMOVE_PV_SIZE_NEEDED };
BEGIN{$TYPEINFO{PEC_LV_NO_SPACE_STRIPED}=["function", "integer"]}
*PEC_LV_NO_SPACE_STRIPED = sub { $LibStoragec::PEC_LV_NO_SPACE_STRIPED };
BEGIN{$TYPEINFO{PEC_LV_NO_SPACE_SINGLE}=["function", "integer"]}
*PEC_LV_NO_SPACE_SINGLE = sub { $LibStoragec::PEC_LV_NO_SPACE_SINGLE };
BEGIN{$TYPEINFO{PEC_LV_PE_DEV_NOT_FOUND}=["function", "integer"]}
*PEC_LV_PE_DEV_NOT_FOUND = sub { $LibStoragec::PEC_LV_PE_DEV_NOT_FOUND };
BEGIN{$TYPEINFO{DM_CHANGE_READONLY}=["function", "integer"]}
*DM_CHANGE_READONLY = sub { $LibStoragec::DM_CHANGE_READONLY };
BEGIN{$TYPEINFO{DM_UNKNOWN_TABLE}=["function", "integer"]}
*DM_UNKNOWN_TABLE = sub { $LibStoragec::DM_UNKNOWN_TABLE };
BEGIN{$TYPEINFO{DM_REMOVE_USED_BY}=["function", "integer"]}
*DM_REMOVE_USED_BY = sub { $LibStoragec::DM_REMOVE_USED_BY };
BEGIN{$TYPEINFO{DM_REMOVE_CREATE_NOT_FOUND}=["function", "integer"]}
*DM_REMOVE_CREATE_NOT_FOUND = sub { $LibStoragec::DM_REMOVE_CREATE_NOT_FOUND };
BEGIN{$TYPEINFO{DM_REMOVE_INVALID_VOLUME}=["function", "integer"]}
*DM_REMOVE_INVALID_VOLUME = sub { $LibStoragec::DM_REMOVE_INVALID_VOLUME };
BEGIN{$TYPEINFO{DM_REMOVE_FAILED}=["function", "integer"]}
*DM_REMOVE_FAILED = sub { $LibStoragec::DM_REMOVE_FAILED };
BEGIN{$TYPEINFO{DM_NOT_IN_LIST}=["function", "integer"]}
*DM_NOT_IN_LIST = sub { $LibStoragec::DM_NOT_IN_LIST };
BEGIN{$TYPEINFO{DASD_NOT_POSSIBLE}=["function", "integer"]}
*DASD_NOT_POSSIBLE = sub { $LibStoragec::DASD_NOT_POSSIBLE };
BEGIN{$TYPEINFO{DASD_FDASD_FAILED}=["function", "integer"]}
*DASD_FDASD_FAILED = sub { $LibStoragec::DASD_FDASD_FAILED };
BEGIN{$TYPEINFO{DASD_DASDFMT_FAILED}=["function", "integer"]}
*DASD_DASDFMT_FAILED = sub { $LibStoragec::DASD_DASDFMT_FAILED };
BEGIN{$TYPEINFO{DMPART_CHANGE_READONLY}=["function", "integer"]}
*DMPART_CHANGE_READONLY = sub { $LibStoragec::DMPART_CHANGE_READONLY };
BEGIN{$TYPEINFO{DMPART_INTERNAL_ERR}=["function", "integer"]}
*DMPART_INTERNAL_ERR = sub { $LibStoragec::DMPART_INTERNAL_ERR };
BEGIN{$TYPEINFO{DMPART_INVALID_VOLUME}=["function", "integer"]}
*DMPART_INVALID_VOLUME = sub { $LibStoragec::DMPART_INVALID_VOLUME };
BEGIN{$TYPEINFO{DMPART_PARTITION_NOT_FOUND}=["function", "integer"]}
*DMPART_PARTITION_NOT_FOUND = sub { $LibStoragec::DMPART_PARTITION_NOT_FOUND };
BEGIN{$TYPEINFO{DMPART_REMOVE_PARTITION_LIST_ERASE}=["function", "integer"]}
*DMPART_REMOVE_PARTITION_LIST_ERASE = sub { $LibStoragec::DMPART_REMOVE_PARTITION_LIST_ERASE };
BEGIN{$TYPEINFO{DMPART_COMMIT_NOTHING_TODO}=["function", "integer"]}
*DMPART_COMMIT_NOTHING_TODO = sub { $LibStoragec::DMPART_COMMIT_NOTHING_TODO };
BEGIN{$TYPEINFO{DMPART_NO_REMOVE}=["function", "integer"]}
*DMPART_NO_REMOVE = sub { $LibStoragec::DMPART_NO_REMOVE };
BEGIN{$TYPEINFO{DMRAID_REMOVE_FAILED}=["function", "integer"]}
*DMRAID_REMOVE_FAILED = sub { $LibStoragec::DMRAID_REMOVE_FAILED };
BEGIN{$TYPEINFO{CONTAINER_INTERNAL_ERROR}=["function", "integer"]}
*CONTAINER_INTERNAL_ERROR = sub { $LibStoragec::CONTAINER_INTERNAL_ERROR };
BEGIN{$TYPEINFO{CONTAINER_INVALID_VIRTUAL_CALL}=["function", "integer"]}
*CONTAINER_INVALID_VIRTUAL_CALL = sub { $LibStoragec::CONTAINER_INVALID_VIRTUAL_CALL };

1;
