CPAN::Groonga

sCloud::Object::Validations;

require 5.6.0;
use strict;
use warnings;
use utf8;
use JSON qw(decode_json);
use Data::Dumper;
use Module::Runtime qw(use_module);
use Log::Any qw($log);
use Da

turn perl hash
sub to_hash {
    return decode_json(JSON->new->convert_blessed->encode( shift ));
}

# used by JSON for serialization
sub TO_JSON { 
    my $self = shift;
    my $_data = {};

eserialize the data
    while ( my ($_key, $_type) = each %{$self->swagger_types} ) {
    	my $_json_attribute = $self->attribute_map->{$_key}; 
        if ($_type =~ /^array\[/i) { # array
      

ect::ProtectWorkbookRequest;

require 5.6.0;
use strict;
use warnings;
use utf8;
use JSON qw(decode_json);
use Data::Dumper;
use Module::Runtime qw(use_module);
use Log::Any qw($log);
use Da

turn perl hash
sub to_hash {
    return decode_json(JSON->new->convert_blessed->encode( shift ));
}

# used by JSON for serialization
sub TO_JSON { 
    my $self = shift;
    my $_data = {};

eserialize the data
    while ( my ($_key, $_type) = each %{$self->swagger_types} ) {
    	my $_json_attribute = $self->attribute_map->{$_key}; 
        if ($_type =~ /^array\[/i) { # array
      

ud::Object::BarcodeResponse;

require 5.6.0;
use strict;
use warnings;
use utf8;
use JSON qw(decode_json);
use Data::Dumper;
use Module::Runtime qw(use_module);
use Log::Any qw($log);
use Da

turn perl hash
sub to_hash {
    return decode_json(JSON->new->convert_blessed->encode( shift ));
}

# used by JSON for serialization
sub TO_JSON { 
    my $self = shift;
    my $_data = {};

eserialize the data
    while ( my ($_key, $_type) = each %{$self->swagger_types} ) {
    	my $_json_attribute = $self->attribute_map->{$_key}; 
        if ($_type =~ /^array\[/i) { # array
      

eCellsCloud::Object::Shapes;

require 5.6.0;
use strict;
use warnings;
use utf8;
use JSON qw(decode_json);
use Data::Dumper;
use Module::Runtime qw(use_module);
use Log::Any qw($log);
use Da

turn perl hash
sub to_hash {
    return decode_json(JSON->new->convert_blessed->encode( shift ));
}

# used by JSON for serialization
sub TO_JSON { 
    my $self = shift;
    my $_data = {};

eserialize the data
    while ( my ($_key, $_type) = each %{$self->swagger_types} ) {
    	my $_json_attribute = $self->attribute_map->{$_key}; 
        if ($_type =~ /^array\[/i) { # array
      

Object::ImageOrPrintOptions;

require 5.6.0;
use strict;
use warnings;
use utf8;
use JSON qw(decode_json);
use Data::Dumper;
use Module::Runtime qw(use_module);
use Log::Any qw($log);
use Da

turn perl hash
sub to_hash {
    return decode_json(JSON->new->convert_blessed->encode( shift ));
}

# used by JSON for serialization
sub TO_JSON { 
    my $self = shift;
    my $_data = {};

eserialize the data
    while ( my ($_key, $_type) = each %{$self->swagger_types} ) {
    	my $_json_attribute = $self->attribute_map->{$_key}; 
        if ($_type =~ /^array\[/i) { # array
      

::Object::NegativeBarFormat;

require 5.6.0;
use strict;
use warnings;
use utf8;
use JSON qw(decode_json);
use Data::Dumper;
use Module::Runtime qw(use_module);
use Log::Any qw($log);
use Da

turn perl hash
sub to_hash {
    return decode_json(JSON->new->convert_blessed->encode( shift ));
}

# used by JSON for serialization
sub TO_JSON { 
    my $self = shift;
    my $_data = {};

eserialize the data
    while ( my ($_key, $_type) = each %{$self->swagger_types} ) {
    	my $_json_attribute = $self->attribute_map->{$_key}; 
        if ($_type =~ /^array\[/i) { # array
      

Cloud::Object::LineResponse;

require 5.6.0;
use strict;
use warnings;
use utf8;
use JSON qw(decode_json);
use Data::Dumper;
use Module::Runtime qw(use_module);
use Log::Any qw($log);
use Da

turn perl hash
sub to_hash {
    return decode_json(JSON->new->convert_blessed->encode( shift ));
}

# used by JSON for serialization
sub TO_JSON { 
    my $self = shift;
    my $_data = {};

eserialize the data
    while ( my ($_key, $_type) = each %{$self->swagger_types} ) {
    	my $_json_attribute = $self->attribute_map->{$_key}; 
        if ($_type =~ /^array\[/i) { # array
      

Object::SingleValueResponse;

require 5.6.0;
use strict;
use warnings;
use utf8;
use JSON qw(decode_json);
use Data::Dumper;
use Module::Runtime qw(use_module);
use Log::Any qw($log);
use Da

turn perl hash
sub to_hash {
    return decode_json(JSON->new->convert_blessed->encode( shift ));
}

# used by JSON for serialization
sub TO_JSON { 
    my $self = shift;
    my $_data = {};

eserialize the data
    while ( my ($_key, $_type) = each %{$self->swagger_types} ) {
    	my $_json_attribute = $self->attribute_map->{$_key}; 
        if ($_type =~ /^array\[/i) { # array
      

O_JSON {

    my $self = shift;

    my $json = {};

    $json->{type}           = $self->type            if $self->type;
    $json->{id}             = $self->id              if $self->id;
    $json->

 $self->state;
    $json->{algorithmRef}   = $self->algorithm_ref   if $self->algorithm_ref;
    $json->{creationDate}   = $self->creation_date   if $self->creation_date;
    $json->{activationDate} =

tivation_date;
    $json->{updateDate}     = $self->update_date     if $self->update_date;
    $json->{expirationDate} = $self->expiration_date if $self->expiration_date;
    $json->{value}          =

cloneDX::Property']]);

sub TO_JSON {

    my $self = shift;

    my $json = {};

    $json->{bom}                  = $self->bom                  if $self->bom;
    $json->{modelParameters}      = $se

    $json->{quantitativeAnalysis} = $self->quantitativeAnalysis if $self->quantitative_analysis;
    $json->{considerations}       = $self->considerations       if $self->considerations;
    $json->{p

roperties}           = $self->properties           if @{$self->properties};

    return $json;

}

1;

=encoding utf-8

=head1 NAME

SBOM::CycloneDX::Component::ModelCard - Model Card

=head1 SYNOPSIS

sub TO_JSON {

    my $self = shift;

    my $json = {type => $self->type, name => $self->name};


    $json->{'mime-type'}        = $self->mime_type           if $self->mime_type;
    $json->{'bom-

>bom_ref;
    $json->{supplier}           = $self->supplier            if $self->supplier;
    $json->{manufacturer}       = $self->manufacturer        if $self->manufacturer;
    $json->{authors}    

f->authors};
    $json->{author}             = $self->author              if $self->author;
    $json->{publisher}          = $self->publisher           if $self->publisher;
    $json->{group}        

OrganizationalContact']);

sub TO_JSON {

    my $self = shift;

    my $json = {};

    $json->{organization} = $self->organization if $self->organization;
    $json->{contact}      = $self->contact 

     if $self->contact;

    return $json;

}

1;

=encoding utf-8

=head1 NAME

SBOM::CycloneDX::DataGovernanceResponsibleParty - Data Custodians

=head1 SYNOPSIS

    SBOM::CycloneDX::DataGovernance

>new });


sub TO_JSON {

    my $self = shift;

    my $json = {};

    $json->{encr}  = $self->encr  if @{$self->encr};
    $json->{prf}   = $self->prf   if @{$self->prf};
    $json->{integ} = $self

f->integ};
    $json->{ke}    = $self->ke    if @{$self->ke};
    $json->{esn}   = $self->esn   if @{$self->esn};
    $json->{auth}  = $self->auth  if @{$self->auth};

    return $json;

}

1;

=encod

=> (is => 'rw', isa => Str);

sub TO_JSON {

    my $self = shift;

    my $json = {};

    $json->{assetType} = $self->asset_type if $self->asset_type;

    $json->{algorithmProperties}   = $self->al

 %{$self->algorithm_properties->TO_JSON};
    $json->{certificateProperties} = $self->certificate_properties if %{$self->certificate_properties->TO_JSON};

    $json->{relatedCryptoMaterialProperties}

operties->TO_JSON};

    $json->{protocolProperties} = $self->protocol_properties if %{$self->protocol_properties->TO_JSON};

    $json->{oid} = $self->oid if $self->oid;

    return $json;

}

1;

=e

:CycloneDX::List->new });


sub TO_JSON {

    my $self = shift;

    my $json = {};

    $json->{mechanism}    = $self->mechanism     if $self->mechanism;
    $json->{algorithmRef} = $self->algorithm

_ref if @{$self->algorithm_ref};

    return $json;

}

1;

=encoding utf-8

=head1 NAME

SBOM::CycloneDX::CryptoProperties::SecuredBy - The mechanism by which the cryptographic asset is secured by

=

 (is => 'rw', isa => Str);


sub TO_JSON {

    my $self = shift;

    my $json = {};

    $json->{lowerBound} = $self->lower_bound if $self->lower_bound;
    $json->{upperBound} = $self->upper_bound 

if $self->upper_bound;

    return $json;

}

1;

=encoding utf-8

=head1 NAME

SBOM::CycloneDX::Component::ConfidenceInterval - Confidence Interval

=head1 SYNOPSIS

    SBOM::CycloneDX::Component::C

:CycloneDX::List->new }
);


sub TO_JSON {

    my $self = shift;

    my $json = {};

    $json->{description} = $self->description if $self->description;
    $json->{collection}  = $self->collection

  if @{$self->collection};

    return $json;

}

1;

=encoding utf-8

=head1 NAME

SBOM::CycloneDX::Component::GraphicsCollection - Graphics Collection

=head1 SYNOPSIS

    SBOM::CycloneDX::Componen

=> Str);

sub TO_JSON {

    my $self = shift;

    my $json = {tagId => $self->tag_id, name => $self->name};

    $json->{version}    = $self->version     if $self->version;
    $json->{tagVersion} =

  $json->{patch}      = $self->patch       if $self->patch;
    $json->{text}       = $self->text        if $self->text;
    $json->{url}        = $self->url         if $self->url;

    return $json;

 (is => 'rw', isa => Str);

sub TO_JSON {

    my $self = shift;

    my $json = {};

    $json->{ancestors}   = $self->ancestors   if @{$self->ancestors};
    $json->{descendants} = $self->descendant

  if @{$self->variants};
    $json->{commits}     = $self->commits     if @{$self->commits};
    $json->{patches}     = $self->patches     if @{$self->patches};
    $json->{notes}       = $self->notes

       if $self->notes;

    return $json;

}

1;

=encoding utf-8

=head1 NAME

SBOM::CycloneDX::Component::Pedigree - Component Pedigree

=head1 SYNOPSIS

    SBOM::CycloneDX::Component::Pedigree->n

=> 'rw', isa      => Enum [qw(base64)]);
has content      => (is => 'rw', required => 1);

sub TO_JSON {

    my $self = shift;

    # TODO  use trigger
    # TODO  guess mime/type from content

    C

   my $json = {content => $content};

    $json->{contentType} = $self->content_type if $self->content_type;
    $json->{encoding}    = $self->encoding     if $self->encoding;

    return $json;

}

1

cifies the optional encoding the text is represented in.

=item $c->TO_JSON

Convert the attachment in JSON.

    say encode_json($attachment);

    # {
    #   "content": "Y29uc29sZS5sb2coJ0dvb2RCeWU