licenses
sequencelengths 1
3
| version
stringclasses 677
values | tree_hash
stringlengths 40
40
| path
stringclasses 1
value | type
stringclasses 2
values | size
stringlengths 2
8
| text
stringlengths 25
67.1M
| package_name
stringlengths 2
41
| repo
stringlengths 33
86
|
|---|---|---|---|---|---|---|---|---|
[
"MIT"
] | 0.1.0 | 2d6ab091a1f4af72f40a76fe35b2c01982aa0bbf | code | 5383 | # This file was generated by the Julia OpenAPI Code Generator
# Do not modify this file directly. Modify the OpenAPI specification instead.
@doc raw"""APIBillingPeriodUsageOut
The current billing period.
APIBillingPeriodUsageOut(;
apiKey=nothing,
subscriptionStarted=nothing,
periodStarted=nothing,
periodEnded=nothing,
stripeCurrentPeriodEnd=nothing,
stripeCurrentPeriodStart=nothing,
billingStatus=nothing,
usage=nothing,
softLimit=nothing,
hardLimit=nothing,
)
- apiKey::String : User API Key.
- subscriptionStarted::Int64 : Datetime when the user subscribed to the plan.
- periodStarted::Int64 : Datetime when the the plan's current period started.
- periodEnded::Int64 : Datetime when the the plan's current period endend.
- stripeCurrentPeriodEnd::Int64 : Datetime when the the plan's current period endend (in Stripe). Internal and Stripe periodicity should ~coincide.
- stripeCurrentPeriodStart::Int64 : Datetime when the the plan's current period started (in Stripe). Internal and Stripe periodicity should ~coincide.
- billingStatus::String : Current period billing status ex OPEN.
- usage::Int64 : Current period usage in units (NB some API endpoints use more than one unit).
- softLimit::Int64 : Current period soft limit (reaching the limit sends an email notification).
- hardLimit::Int64 : Current period hard limit (reaching the limit sends an email notification and blocks the API Key).
"""
Base.@kwdef mutable struct APIBillingPeriodUsageOut <: OpenAPI.APIModel
apiKey::Union{Nothing, String} = nothing
subscriptionStarted::Union{Nothing, Int64} = nothing
periodStarted::Union{Nothing, Int64} = nothing
periodEnded::Union{Nothing, Int64} = nothing
stripeCurrentPeriodEnd::Union{Nothing, Int64} = nothing
stripeCurrentPeriodStart::Union{Nothing, Int64} = nothing
billingStatus::Union{Nothing, String} = nothing
usage::Union{Nothing, Int64} = nothing
softLimit::Union{Nothing, Int64} = nothing
hardLimit::Union{Nothing, Int64} = nothing
function APIBillingPeriodUsageOut(apiKey, subscriptionStarted, periodStarted, periodEnded, stripeCurrentPeriodEnd, stripeCurrentPeriodStart, billingStatus, usage, softLimit, hardLimit, )
OpenAPI.validate_property(APIBillingPeriodUsageOut, Symbol("apiKey"), apiKey)
OpenAPI.validate_property(APIBillingPeriodUsageOut, Symbol("subscriptionStarted"), subscriptionStarted)
OpenAPI.validate_property(APIBillingPeriodUsageOut, Symbol("periodStarted"), periodStarted)
OpenAPI.validate_property(APIBillingPeriodUsageOut, Symbol("periodEnded"), periodEnded)
OpenAPI.validate_property(APIBillingPeriodUsageOut, Symbol("stripeCurrentPeriodEnd"), stripeCurrentPeriodEnd)
OpenAPI.validate_property(APIBillingPeriodUsageOut, Symbol("stripeCurrentPeriodStart"), stripeCurrentPeriodStart)
OpenAPI.validate_property(APIBillingPeriodUsageOut, Symbol("billingStatus"), billingStatus)
OpenAPI.validate_property(APIBillingPeriodUsageOut, Symbol("usage"), usage)
OpenAPI.validate_property(APIBillingPeriodUsageOut, Symbol("softLimit"), softLimit)
OpenAPI.validate_property(APIBillingPeriodUsageOut, Symbol("hardLimit"), hardLimit)
return new(apiKey, subscriptionStarted, periodStarted, periodEnded, stripeCurrentPeriodEnd, stripeCurrentPeriodStart, billingStatus, usage, softLimit, hardLimit, )
end
end # type APIBillingPeriodUsageOut
const _property_types_APIBillingPeriodUsageOut = Dict{Symbol,String}(Symbol("apiKey")=>"String", Symbol("subscriptionStarted")=>"Int64", Symbol("periodStarted")=>"Int64", Symbol("periodEnded")=>"Int64", Symbol("stripeCurrentPeriodEnd")=>"Int64", Symbol("stripeCurrentPeriodStart")=>"Int64", Symbol("billingStatus")=>"String", Symbol("usage")=>"Int64", Symbol("softLimit")=>"Int64", Symbol("hardLimit")=>"Int64", )
OpenAPI.property_type(::Type{ APIBillingPeriodUsageOut }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_APIBillingPeriodUsageOut[name]))}
function check_required(o::APIBillingPeriodUsageOut)
true
end
function OpenAPI.validate_property(::Type{ APIBillingPeriodUsageOut }, name::Symbol, val)
if name === Symbol("subscriptionStarted")
OpenAPI.validate_param(name, "APIBillingPeriodUsageOut", :format, val, "int64")
end
if name === Symbol("periodStarted")
OpenAPI.validate_param(name, "APIBillingPeriodUsageOut", :format, val, "int64")
end
if name === Symbol("periodEnded")
OpenAPI.validate_param(name, "APIBillingPeriodUsageOut", :format, val, "int64")
end
if name === Symbol("stripeCurrentPeriodEnd")
OpenAPI.validate_param(name, "APIBillingPeriodUsageOut", :format, val, "int64")
end
if name === Symbol("stripeCurrentPeriodStart")
OpenAPI.validate_param(name, "APIBillingPeriodUsageOut", :format, val, "int64")
end
if name === Symbol("usage")
OpenAPI.validate_param(name, "APIBillingPeriodUsageOut", :format, val, "int64")
end
if name === Symbol("softLimit")
OpenAPI.validate_param(name, "APIBillingPeriodUsageOut", :format, val, "int64")
end
if name === Symbol("hardLimit")
OpenAPI.validate_param(name, "APIBillingPeriodUsageOut", :format, val, "int64")
end
end
| NamSor | https://github.com/NeroBlackstone/NamSor.jl.git |
|
[
"MIT"
] | 0.1.0 | 2d6ab091a1f4af72f40a76fe35b2c01982aa0bbf | code | 2401 | # This file was generated by the Julia OpenAPI Code Generator
# Do not modify this file directly. Modify the OpenAPI specification instead.
@doc raw"""APIClassifierOut
The list of classifiers and versions.
APIClassifierOut(;
classifierName=nothing,
serving=nothing,
learning=nothing,
shuttingDown=nothing,
probabilityCalibrated=nothing,
)
- classifierName::String : The classifier name
- serving::Bool : True if the classifier is serving requests (has reached minimal learning, is not shutting down)
- learning::Bool : True if the classifier is learning
- shuttingDown::Bool : True if the classifier is shutting down
- probabilityCalibrated::Bool : True if the classifier has finished the initial learning and calibrated probabilities (meanwhile, during initial learning, probabilities will be equal to -1)
"""
Base.@kwdef mutable struct APIClassifierOut <: OpenAPI.APIModel
classifierName::Union{Nothing, String} = nothing
serving::Union{Nothing, Bool} = nothing
learning::Union{Nothing, Bool} = nothing
shuttingDown::Union{Nothing, Bool} = nothing
probabilityCalibrated::Union{Nothing, Bool} = nothing
function APIClassifierOut(classifierName, serving, learning, shuttingDown, probabilityCalibrated, )
OpenAPI.validate_property(APIClassifierOut, Symbol("classifierName"), classifierName)
OpenAPI.validate_property(APIClassifierOut, Symbol("serving"), serving)
OpenAPI.validate_property(APIClassifierOut, Symbol("learning"), learning)
OpenAPI.validate_property(APIClassifierOut, Symbol("shuttingDown"), shuttingDown)
OpenAPI.validate_property(APIClassifierOut, Symbol("probabilityCalibrated"), probabilityCalibrated)
return new(classifierName, serving, learning, shuttingDown, probabilityCalibrated, )
end
end # type APIClassifierOut
const _property_types_APIClassifierOut = Dict{Symbol,String}(Symbol("classifierName")=>"String", Symbol("serving")=>"Bool", Symbol("learning")=>"Bool", Symbol("shuttingDown")=>"Bool", Symbol("probabilityCalibrated")=>"Bool", )
OpenAPI.property_type(::Type{ APIClassifierOut }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_APIClassifierOut[name]))}
function check_required(o::APIClassifierOut)
true
end
function OpenAPI.validate_property(::Type{ APIClassifierOut }, name::Symbol, val)
end
| NamSor | https://github.com/NeroBlackstone/NamSor.jl.git |
|
[
"MIT"
] | 0.1.0 | 2d6ab091a1f4af72f40a76fe35b2c01982aa0bbf | code | 1945 | # This file was generated by the Julia OpenAPI Code Generator
# Do not modify this file directly. Modify the OpenAPI specification instead.
@doc raw"""APIClassifierTaxonomyOut
APIClassifierTaxonomyOut(;
classifierName=nothing,
taxonomyClasses=nothing,
classifyingScripts=nothing,
)
- classifierName::String : Name of the classifier as per apiStatus (corresponds also to the name of the service in apiServices)
- taxonomyClasses::Vector{String} : The taxonomy classes this classifier classifies to
- classifyingScripts::Vector{String} : The scripts / alphabets this classifiers classifies to
"""
Base.@kwdef mutable struct APIClassifierTaxonomyOut <: OpenAPI.APIModel
classifierName::Union{Nothing, String} = nothing
taxonomyClasses::Union{Nothing, Vector{String}} = nothing
classifyingScripts::Union{Nothing, Vector{String}} = nothing
function APIClassifierTaxonomyOut(classifierName, taxonomyClasses, classifyingScripts, )
OpenAPI.validate_property(APIClassifierTaxonomyOut, Symbol("classifierName"), classifierName)
OpenAPI.validate_property(APIClassifierTaxonomyOut, Symbol("taxonomyClasses"), taxonomyClasses)
OpenAPI.validate_property(APIClassifierTaxonomyOut, Symbol("classifyingScripts"), classifyingScripts)
return new(classifierName, taxonomyClasses, classifyingScripts, )
end
end # type APIClassifierTaxonomyOut
const _property_types_APIClassifierTaxonomyOut = Dict{Symbol,String}(Symbol("classifierName")=>"String", Symbol("taxonomyClasses")=>"Vector{String}", Symbol("classifyingScripts")=>"Vector{String}", )
OpenAPI.property_type(::Type{ APIClassifierTaxonomyOut }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_APIClassifierTaxonomyOut[name]))}
function check_required(o::APIClassifierTaxonomyOut)
true
end
function OpenAPI.validate_property(::Type{ APIClassifierTaxonomyOut }, name::Symbol, val)
end
| NamSor | https://github.com/NeroBlackstone/NamSor.jl.git |
|
[
"MIT"
] | 0.1.0 | 2d6ab091a1f4af72f40a76fe35b2c01982aa0bbf | code | 1514 | # This file was generated by the Julia OpenAPI Code Generator
# Do not modify this file directly. Modify the OpenAPI specification instead.
@doc raw"""APIClassifiersStatusOut
APIClassifiersStatusOut(;
softwareVersion=nothing,
classifiers=nothing,
)
- softwareVersion::SoftwareVersionOut
- classifiers::Vector{APIClassifierOut} : The list of classifiers and versions.
"""
Base.@kwdef mutable struct APIClassifiersStatusOut <: OpenAPI.APIModel
softwareVersion = nothing # spec type: Union{ Nothing, SoftwareVersionOut }
classifiers::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{APIClassifierOut} }
function APIClassifiersStatusOut(softwareVersion, classifiers, )
OpenAPI.validate_property(APIClassifiersStatusOut, Symbol("softwareVersion"), softwareVersion)
OpenAPI.validate_property(APIClassifiersStatusOut, Symbol("classifiers"), classifiers)
return new(softwareVersion, classifiers, )
end
end # type APIClassifiersStatusOut
const _property_types_APIClassifiersStatusOut = Dict{Symbol,String}(Symbol("softwareVersion")=>"SoftwareVersionOut", Symbol("classifiers")=>"Vector{APIClassifierOut}", )
OpenAPI.property_type(::Type{ APIClassifiersStatusOut }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_APIClassifiersStatusOut[name]))}
function check_required(o::APIClassifiersStatusOut)
true
end
function OpenAPI.validate_property(::Type{ APIClassifiersStatusOut }, name::Symbol, val)
end
| NamSor | https://github.com/NeroBlackstone/NamSor.jl.git |
|
[
"MIT"
] | 0.1.0 | 2d6ab091a1f4af72f40a76fe35b2c01982aa0bbf | code | 3773 | # This file was generated by the Julia OpenAPI Code Generator
# Do not modify this file directly. Modify the OpenAPI specification instead.
@doc raw"""APICounterV2Out
Detailed usage as reported by the deduplicating API counter.
APICounterV2Out(;
apiKey=nothing,
apiService=nothing,
hostAddress=nothing,
createdDateTime=nothing,
totalUsage=nothing,
lastFlushedDateTime=nothing,
lastUsedDateTime=nothing,
serviceFeaturesUsage=nothing,
)
- apiKey::APIKeyOut
- apiService::String : The apiService corresponds to the classifier name.
- hostAddress::String : The processing hostAddress.
- createdDateTime::Int64 : The create datetime of the counter.
- totalUsage::Int64 : The usage of the counter.
- lastFlushedDateTime::Int64 : The flush datetime of the counter.
- lastUsedDateTime::Int64 : The last usage datetime of the counter.
- serviceFeaturesUsage::Dict{String, Int64} : Usage of special features, such as Chinese, Japanese.
"""
Base.@kwdef mutable struct APICounterV2Out <: OpenAPI.APIModel
apiKey = nothing # spec type: Union{ Nothing, APIKeyOut }
apiService::Union{Nothing, String} = nothing
hostAddress::Union{Nothing, String} = nothing
createdDateTime::Union{Nothing, Int64} = nothing
totalUsage::Union{Nothing, Int64} = nothing
lastFlushedDateTime::Union{Nothing, Int64} = nothing
lastUsedDateTime::Union{Nothing, Int64} = nothing
serviceFeaturesUsage::Union{Nothing, Dict{String, Int64}} = nothing
function APICounterV2Out(apiKey, apiService, hostAddress, createdDateTime, totalUsage, lastFlushedDateTime, lastUsedDateTime, serviceFeaturesUsage, )
OpenAPI.validate_property(APICounterV2Out, Symbol("apiKey"), apiKey)
OpenAPI.validate_property(APICounterV2Out, Symbol("apiService"), apiService)
OpenAPI.validate_property(APICounterV2Out, Symbol("hostAddress"), hostAddress)
OpenAPI.validate_property(APICounterV2Out, Symbol("createdDateTime"), createdDateTime)
OpenAPI.validate_property(APICounterV2Out, Symbol("totalUsage"), totalUsage)
OpenAPI.validate_property(APICounterV2Out, Symbol("lastFlushedDateTime"), lastFlushedDateTime)
OpenAPI.validate_property(APICounterV2Out, Symbol("lastUsedDateTime"), lastUsedDateTime)
OpenAPI.validate_property(APICounterV2Out, Symbol("serviceFeaturesUsage"), serviceFeaturesUsage)
return new(apiKey, apiService, hostAddress, createdDateTime, totalUsage, lastFlushedDateTime, lastUsedDateTime, serviceFeaturesUsage, )
end
end # type APICounterV2Out
const _property_types_APICounterV2Out = Dict{Symbol,String}(Symbol("apiKey")=>"APIKeyOut", Symbol("apiService")=>"String", Symbol("hostAddress")=>"String", Symbol("createdDateTime")=>"Int64", Symbol("totalUsage")=>"Int64", Symbol("lastFlushedDateTime")=>"Int64", Symbol("lastUsedDateTime")=>"Int64", Symbol("serviceFeaturesUsage")=>"Dict{String, Int64}", )
OpenAPI.property_type(::Type{ APICounterV2Out }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_APICounterV2Out[name]))}
function check_required(o::APICounterV2Out)
true
end
function OpenAPI.validate_property(::Type{ APICounterV2Out }, name::Symbol, val)
if name === Symbol("createdDateTime")
OpenAPI.validate_param(name, "APICounterV2Out", :format, val, "int64")
end
if name === Symbol("totalUsage")
OpenAPI.validate_param(name, "APICounterV2Out", :format, val, "int64")
end
if name === Symbol("lastFlushedDateTime")
OpenAPI.validate_param(name, "APICounterV2Out", :format, val, "int64")
end
if name === Symbol("lastUsedDateTime")
OpenAPI.validate_param(name, "APICounterV2Out", :format, val, "int64")
end
end
| NamSor | https://github.com/NeroBlackstone/NamSor.jl.git |
|
[
"MIT"
] | 0.1.0 | 2d6ab091a1f4af72f40a76fe35b2c01982aa0bbf | code | 4428 | # This file was generated by the Julia OpenAPI Code Generator
# Do not modify this file directly. Modify the OpenAPI specification instead.
@doc raw"""APIKeyOut
APIKeyOut(;
apiKey=nothing,
userId=nothing,
admin=nothing,
vetted=nothing,
learnable=nothing,
anonymized=nothing,
partner=nothing,
striped=nothing,
corporate=nothing,
disabled=nothing,
explainable=nothing,
ipAddress=nothing,
communityEngageOption=nothing,
)
- apiKey::String : The user API Key.
- userId::String : The user identifier.
- admin::Bool : The API Key has admin role.
- vetted::Bool : The API Key is vetted (assumed truthful) for machine learning.
- learnable::Bool : The API Key is learnable (without assuming truthfulness) for machine learning. Set learnable=false and anonymized=true for highest privacy (ie. to forget data as it's processed).
- anonymized::Bool : The API Key is anonymized (using SHA-252 digest for logging). Set learnable=false and anonymized=true for highest privacy (ie. to forget data as it's processed).
- partner::Bool : The API Key has partner role.
- striped::Bool : The API Key is associated to a valid Stripe account.
- corporate::Bool : The API Key has role corporate (ex SWIFT payments instead of Stripe payments).
- disabled::Bool : The API Key is temporarily or permanently disabled.
- explainable::Bool : The API Key supports the AI explainability option (may require a specific license).
- ipAddress::String
- communityEngageOption::CommunityEngageOptionOut
"""
Base.@kwdef mutable struct APIKeyOut <: OpenAPI.APIModel
apiKey::Union{Nothing, String} = nothing
userId::Union{Nothing, String} = nothing
admin::Union{Nothing, Bool} = nothing
vetted::Union{Nothing, Bool} = nothing
learnable::Union{Nothing, Bool} = nothing
anonymized::Union{Nothing, Bool} = nothing
partner::Union{Nothing, Bool} = nothing
striped::Union{Nothing, Bool} = nothing
corporate::Union{Nothing, Bool} = nothing
disabled::Union{Nothing, Bool} = nothing
explainable::Union{Nothing, Bool} = nothing
ipAddress::Union{Nothing, String} = nothing
communityEngageOption = nothing # spec type: Union{ Nothing, CommunityEngageOptionOut }
function APIKeyOut(apiKey, userId, admin, vetted, learnable, anonymized, partner, striped, corporate, disabled, explainable, ipAddress, communityEngageOption, )
OpenAPI.validate_property(APIKeyOut, Symbol("apiKey"), apiKey)
OpenAPI.validate_property(APIKeyOut, Symbol("userId"), userId)
OpenAPI.validate_property(APIKeyOut, Symbol("admin"), admin)
OpenAPI.validate_property(APIKeyOut, Symbol("vetted"), vetted)
OpenAPI.validate_property(APIKeyOut, Symbol("learnable"), learnable)
OpenAPI.validate_property(APIKeyOut, Symbol("anonymized"), anonymized)
OpenAPI.validate_property(APIKeyOut, Symbol("partner"), partner)
OpenAPI.validate_property(APIKeyOut, Symbol("striped"), striped)
OpenAPI.validate_property(APIKeyOut, Symbol("corporate"), corporate)
OpenAPI.validate_property(APIKeyOut, Symbol("disabled"), disabled)
OpenAPI.validate_property(APIKeyOut, Symbol("explainable"), explainable)
OpenAPI.validate_property(APIKeyOut, Symbol("ipAddress"), ipAddress)
OpenAPI.validate_property(APIKeyOut, Symbol("communityEngageOption"), communityEngageOption)
return new(apiKey, userId, admin, vetted, learnable, anonymized, partner, striped, corporate, disabled, explainable, ipAddress, communityEngageOption, )
end
end # type APIKeyOut
const _property_types_APIKeyOut = Dict{Symbol,String}(Symbol("apiKey")=>"String", Symbol("userId")=>"String", Symbol("admin")=>"Bool", Symbol("vetted")=>"Bool", Symbol("learnable")=>"Bool", Symbol("anonymized")=>"Bool", Symbol("partner")=>"Bool", Symbol("striped")=>"Bool", Symbol("corporate")=>"Bool", Symbol("disabled")=>"Bool", Symbol("explainable")=>"Bool", Symbol("ipAddress")=>"String", Symbol("communityEngageOption")=>"CommunityEngageOptionOut", )
OpenAPI.property_type(::Type{ APIKeyOut }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_APIKeyOut[name]))}
function check_required(o::APIKeyOut)
true
end
function OpenAPI.validate_property(::Type{ APIKeyOut }, name::Symbol, val)
end
| NamSor | https://github.com/NeroBlackstone/NamSor.jl.git |
|
[
"MIT"
] | 0.1.0 | 2d6ab091a1f4af72f40a76fe35b2c01982aa0bbf | code | 3090 | # This file was generated by the Julia OpenAPI Code Generator
# Do not modify this file directly. Modify the OpenAPI specification instead.
@doc raw"""APIPeriodUsageOut
APIPeriodUsageOut(;
subscription=nothing,
billingPeriod=nothing,
overageExclTax=nothing,
overageInclTax=nothing,
overageCurrency=nothing,
overageQuantity=nothing,
)
- subscription::APIPlanSubscriptionOut
- billingPeriod::APIBillingPeriodUsageOut
- overageExclTax::Float64 : Overage amount including any tax.
- overageInclTax::Float64 : Overage amount including tax (if applicable).
- overageCurrency::String : Currency of the overage amount.
- overageQuantity::Int64 : Quantity above monthly quota of the current subscritpion, in units.
"""
Base.@kwdef mutable struct APIPeriodUsageOut <: OpenAPI.APIModel
subscription = nothing # spec type: Union{ Nothing, APIPlanSubscriptionOut }
billingPeriod = nothing # spec type: Union{ Nothing, APIBillingPeriodUsageOut }
overageExclTax::Union{Nothing, Float64} = nothing
overageInclTax::Union{Nothing, Float64} = nothing
overageCurrency::Union{Nothing, String} = nothing
overageQuantity::Union{Nothing, Int64} = nothing
function APIPeriodUsageOut(subscription, billingPeriod, overageExclTax, overageInclTax, overageCurrency, overageQuantity, )
OpenAPI.validate_property(APIPeriodUsageOut, Symbol("subscription"), subscription)
OpenAPI.validate_property(APIPeriodUsageOut, Symbol("billingPeriod"), billingPeriod)
OpenAPI.validate_property(APIPeriodUsageOut, Symbol("overageExclTax"), overageExclTax)
OpenAPI.validate_property(APIPeriodUsageOut, Symbol("overageInclTax"), overageInclTax)
OpenAPI.validate_property(APIPeriodUsageOut, Symbol("overageCurrency"), overageCurrency)
OpenAPI.validate_property(APIPeriodUsageOut, Symbol("overageQuantity"), overageQuantity)
return new(subscription, billingPeriod, overageExclTax, overageInclTax, overageCurrency, overageQuantity, )
end
end # type APIPeriodUsageOut
const _property_types_APIPeriodUsageOut = Dict{Symbol,String}(Symbol("subscription")=>"APIPlanSubscriptionOut", Symbol("billingPeriod")=>"APIBillingPeriodUsageOut", Symbol("overageExclTax")=>"Float64", Symbol("overageInclTax")=>"Float64", Symbol("overageCurrency")=>"String", Symbol("overageQuantity")=>"Int64", )
OpenAPI.property_type(::Type{ APIPeriodUsageOut }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_APIPeriodUsageOut[name]))}
function check_required(o::APIPeriodUsageOut)
true
end
function OpenAPI.validate_property(::Type{ APIPeriodUsageOut }, name::Symbol, val)
if name === Symbol("overageExclTax")
OpenAPI.validate_param(name, "APIPeriodUsageOut", :format, val, "double")
end
if name === Symbol("overageInclTax")
OpenAPI.validate_param(name, "APIPeriodUsageOut", :format, val, "double")
end
if name === Symbol("overageQuantity")
OpenAPI.validate_param(name, "APIPeriodUsageOut", :format, val, "int64")
end
end
| NamSor | https://github.com/NeroBlackstone/NamSor.jl.git |
|
[
"MIT"
] | 0.1.0 | 2d6ab091a1f4af72f40a76fe35b2c01982aa0bbf | code | 7943 | # This file was generated by the Julia OpenAPI Code Generator
# Do not modify this file directly. Modify the OpenAPI specification instead.
@doc raw"""APIPlanSubscriptionOut
The API Plan governing the subscription.
APIPlanSubscriptionOut(;
apiKey=nothing,
planStarted=nothing,
priorPlanStarted=nothing,
planEnded=nothing,
taxRate=nothing,
planName=nothing,
planBaseFeesKey=nothing,
planStatus=nothing,
planQuota=nothing,
priceUSD=nothing,
priceOverageUSD=nothing,
price=nothing,
priceOverage=nothing,
currency=nothing,
currencyFactor=nothing,
stripeCustomerId=nothing,
stripeStatus=nothing,
stripeSubscription=nothing,
userId=nothing,
)
- apiKey::String : User API Key.
- planStarted::Int64 : Datetime when the user subscribed to the current plan.
- priorPlanStarted::Int64 : Datetime when the user subscribed to the prior plan.
- planEnded::Int64 : Datetime when the user ended the plan.
- taxRate::Float64 : Applicable tax rate for the plan.
- planName::String : Current plan name.
- planBaseFeesKey::String : Current plan key (as in Stripe product).
- planStatus::String : Plan status.
- planQuota::Int64 : Current plan quota in quantity of units (NB: some API use several units per name).
- priceUSD::Float64 : Current plan monthly price expressed in USD (includes a free quota).
- priceOverageUSD::Float64 : Current plan price for overages expressed in USD (extra price per unit above the free quota).
- price::Float64 : Current plan price for overages expressed in Currency (extra price per unit above the free quota).
- priceOverage::Float64 : Current plan price for overages expressed in Currency (extra price per unit above the free quota).
- currency::String : Current plan Currency for prices.
- currencyFactor::Float64 : For USD, GBP, EUR - the factor is 1.
- stripeCustomerId::String : Stripe customer identifier.
- stripeStatus::String : Stripe status ex active.
- stripeSubscription::String : Stripe subscription identifier.
- userId::String : Internal user identifier.
"""
Base.@kwdef mutable struct APIPlanSubscriptionOut <: OpenAPI.APIModel
apiKey::Union{Nothing, String} = nothing
planStarted::Union{Nothing, Int64} = nothing
priorPlanStarted::Union{Nothing, Int64} = nothing
planEnded::Union{Nothing, Int64} = nothing
taxRate::Union{Nothing, Float64} = nothing
planName::Union{Nothing, String} = nothing
planBaseFeesKey::Union{Nothing, String} = nothing
planStatus::Union{Nothing, String} = nothing
planQuota::Union{Nothing, Int64} = nothing
priceUSD::Union{Nothing, Float64} = nothing
priceOverageUSD::Union{Nothing, Float64} = nothing
price::Union{Nothing, Float64} = nothing
priceOverage::Union{Nothing, Float64} = nothing
currency::Union{Nothing, String} = nothing
currencyFactor::Union{Nothing, Float64} = nothing
stripeCustomerId::Union{Nothing, String} = nothing
stripeStatus::Union{Nothing, String} = nothing
stripeSubscription::Union{Nothing, String} = nothing
userId::Union{Nothing, String} = nothing
function APIPlanSubscriptionOut(apiKey, planStarted, priorPlanStarted, planEnded, taxRate, planName, planBaseFeesKey, planStatus, planQuota, priceUSD, priceOverageUSD, price, priceOverage, currency, currencyFactor, stripeCustomerId, stripeStatus, stripeSubscription, userId, )
OpenAPI.validate_property(APIPlanSubscriptionOut, Symbol("apiKey"), apiKey)
OpenAPI.validate_property(APIPlanSubscriptionOut, Symbol("planStarted"), planStarted)
OpenAPI.validate_property(APIPlanSubscriptionOut, Symbol("priorPlanStarted"), priorPlanStarted)
OpenAPI.validate_property(APIPlanSubscriptionOut, Symbol("planEnded"), planEnded)
OpenAPI.validate_property(APIPlanSubscriptionOut, Symbol("taxRate"), taxRate)
OpenAPI.validate_property(APIPlanSubscriptionOut, Symbol("planName"), planName)
OpenAPI.validate_property(APIPlanSubscriptionOut, Symbol("planBaseFeesKey"), planBaseFeesKey)
OpenAPI.validate_property(APIPlanSubscriptionOut, Symbol("planStatus"), planStatus)
OpenAPI.validate_property(APIPlanSubscriptionOut, Symbol("planQuota"), planQuota)
OpenAPI.validate_property(APIPlanSubscriptionOut, Symbol("priceUSD"), priceUSD)
OpenAPI.validate_property(APIPlanSubscriptionOut, Symbol("priceOverageUSD"), priceOverageUSD)
OpenAPI.validate_property(APIPlanSubscriptionOut, Symbol("price"), price)
OpenAPI.validate_property(APIPlanSubscriptionOut, Symbol("priceOverage"), priceOverage)
OpenAPI.validate_property(APIPlanSubscriptionOut, Symbol("currency"), currency)
OpenAPI.validate_property(APIPlanSubscriptionOut, Symbol("currencyFactor"), currencyFactor)
OpenAPI.validate_property(APIPlanSubscriptionOut, Symbol("stripeCustomerId"), stripeCustomerId)
OpenAPI.validate_property(APIPlanSubscriptionOut, Symbol("stripeStatus"), stripeStatus)
OpenAPI.validate_property(APIPlanSubscriptionOut, Symbol("stripeSubscription"), stripeSubscription)
OpenAPI.validate_property(APIPlanSubscriptionOut, Symbol("userId"), userId)
return new(apiKey, planStarted, priorPlanStarted, planEnded, taxRate, planName, planBaseFeesKey, planStatus, planQuota, priceUSD, priceOverageUSD, price, priceOverage, currency, currencyFactor, stripeCustomerId, stripeStatus, stripeSubscription, userId, )
end
end # type APIPlanSubscriptionOut
const _property_types_APIPlanSubscriptionOut = Dict{Symbol,String}(Symbol("apiKey")=>"String", Symbol("planStarted")=>"Int64", Symbol("priorPlanStarted")=>"Int64", Symbol("planEnded")=>"Int64", Symbol("taxRate")=>"Float64", Symbol("planName")=>"String", Symbol("planBaseFeesKey")=>"String", Symbol("planStatus")=>"String", Symbol("planQuota")=>"Int64", Symbol("priceUSD")=>"Float64", Symbol("priceOverageUSD")=>"Float64", Symbol("price")=>"Float64", Symbol("priceOverage")=>"Float64", Symbol("currency")=>"String", Symbol("currencyFactor")=>"Float64", Symbol("stripeCustomerId")=>"String", Symbol("stripeStatus")=>"String", Symbol("stripeSubscription")=>"String", Symbol("userId")=>"String", )
OpenAPI.property_type(::Type{ APIPlanSubscriptionOut }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_APIPlanSubscriptionOut[name]))}
function check_required(o::APIPlanSubscriptionOut)
true
end
function OpenAPI.validate_property(::Type{ APIPlanSubscriptionOut }, name::Symbol, val)
if name === Symbol("planStarted")
OpenAPI.validate_param(name, "APIPlanSubscriptionOut", :format, val, "int64")
end
if name === Symbol("priorPlanStarted")
OpenAPI.validate_param(name, "APIPlanSubscriptionOut", :format, val, "int64")
end
if name === Symbol("planEnded")
OpenAPI.validate_param(name, "APIPlanSubscriptionOut", :format, val, "int64")
end
if name === Symbol("taxRate")
OpenAPI.validate_param(name, "APIPlanSubscriptionOut", :format, val, "double")
end
if name === Symbol("planQuota")
OpenAPI.validate_param(name, "APIPlanSubscriptionOut", :format, val, "int64")
end
if name === Symbol("priceUSD")
OpenAPI.validate_param(name, "APIPlanSubscriptionOut", :format, val, "double")
end
if name === Symbol("priceOverageUSD")
OpenAPI.validate_param(name, "APIPlanSubscriptionOut", :format, val, "double")
end
if name === Symbol("price")
OpenAPI.validate_param(name, "APIPlanSubscriptionOut", :format, val, "double")
end
if name === Symbol("priceOverage")
OpenAPI.validate_param(name, "APIPlanSubscriptionOut", :format, val, "double")
end
if name === Symbol("currencyFactor")
OpenAPI.validate_param(name, "APIPlanSubscriptionOut", :format, val, "double")
end
end
| NamSor | https://github.com/NeroBlackstone/NamSor.jl.git |
|
[
"MIT"
] | 0.1.0 | 2d6ab091a1f4af72f40a76fe35b2c01982aa0bbf | code | 1908 | # This file was generated by the Julia OpenAPI Code Generator
# Do not modify this file directly. Modify the OpenAPI specification instead.
@doc raw"""APIServiceOut
List of API Services
APIServiceOut(;
serviceName=nothing,
serviceGroup=nothing,
costInUnits=nothing,
)
- serviceName::String : A service name corresponds to classifier name in apiStatus (ex. personalname_gender or personalfullname_gender)
- serviceGroup::String : Groups together classifiers providing a similar service (ex. gender groups personalname_gender and personalfullname_gender)
- costInUnits::Int64 : Indicates how many units per call this service costs (ex. the number of units per name)
"""
Base.@kwdef mutable struct APIServiceOut <: OpenAPI.APIModel
serviceName::Union{Nothing, String} = nothing
serviceGroup::Union{Nothing, String} = nothing
costInUnits::Union{Nothing, Int64} = nothing
function APIServiceOut(serviceName, serviceGroup, costInUnits, )
OpenAPI.validate_property(APIServiceOut, Symbol("serviceName"), serviceName)
OpenAPI.validate_property(APIServiceOut, Symbol("serviceGroup"), serviceGroup)
OpenAPI.validate_property(APIServiceOut, Symbol("costInUnits"), costInUnits)
return new(serviceName, serviceGroup, costInUnits, )
end
end # type APIServiceOut
const _property_types_APIServiceOut = Dict{Symbol,String}(Symbol("serviceName")=>"String", Symbol("serviceGroup")=>"String", Symbol("costInUnits")=>"Int64", )
OpenAPI.property_type(::Type{ APIServiceOut }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_APIServiceOut[name]))}
function check_required(o::APIServiceOut)
true
end
function OpenAPI.validate_property(::Type{ APIServiceOut }, name::Symbol, val)
if name === Symbol("costInUnits")
OpenAPI.validate_param(name, "APIServiceOut", :format, val, "int32")
end
end
| NamSor | https://github.com/NeroBlackstone/NamSor.jl.git |
|
[
"MIT"
] | 0.1.0 | 2d6ab091a1f4af72f40a76fe35b2c01982aa0bbf | code | 1048 | # This file was generated by the Julia OpenAPI Code Generator
# Do not modify this file directly. Modify the OpenAPI specification instead.
@doc raw"""APIServicesOut
APIServicesOut(;
apiServices=nothing,
)
- apiServices::Vector{APIServiceOut} : List of API Services
"""
Base.@kwdef mutable struct APIServicesOut <: OpenAPI.APIModel
apiServices::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{APIServiceOut} }
function APIServicesOut(apiServices, )
OpenAPI.validate_property(APIServicesOut, Symbol("apiServices"), apiServices)
return new(apiServices, )
end
end # type APIServicesOut
const _property_types_APIServicesOut = Dict{Symbol,String}(Symbol("apiServices")=>"Vector{APIServiceOut}", )
OpenAPI.property_type(::Type{ APIServicesOut }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_APIServicesOut[name]))}
function check_required(o::APIServicesOut)
true
end
function OpenAPI.validate_property(::Type{ APIServicesOut }, name::Symbol, val)
end
| NamSor | https://github.com/NeroBlackstone/NamSor.jl.git |
|
[
"MIT"
] | 0.1.0 | 2d6ab091a1f4af72f40a76fe35b2c01982aa0bbf | code | 3551 | # This file was generated by the Julia OpenAPI Code Generator
# Do not modify this file directly. Modify the OpenAPI specification instead.
@doc raw"""APIUsageAggregatedOut
APIUsageAggregatedOut(;
timeUnit=nothing,
periodStart=nothing,
periodEnd=nothing,
totalUsage=nothing,
historyTruncated=nothing,
data=nothing,
colHeaders=nothing,
rowHeaders=nothing,
)
- timeUnit::String : Time unit is DAY, WEEK or MONTH depending on prior usage
- periodStart::Int64 : Start datetime of the reporting period
- periodEnd::Int64 : End datetime of the reporting period
- totalUsage::Int64 : Total usage in the current period
- historyTruncated::Bool : If the history was truncaded due to data limit
- data::Vector{Vector{Int64}} : Data points : usage per DAY, WEEK or MONTH and per apiService
- colHeaders::Vector{String} : apiServices as column headers
- rowHeaders::Vector{String} : dates as row headers
"""
Base.@kwdef mutable struct APIUsageAggregatedOut <: OpenAPI.APIModel
timeUnit::Union{Nothing, String} = nothing
periodStart::Union{Nothing, Int64} = nothing
periodEnd::Union{Nothing, Int64} = nothing
totalUsage::Union{Nothing, Int64} = nothing
historyTruncated::Union{Nothing, Bool} = nothing
data::Union{Nothing, Vector{Vector{Int64}}} = nothing
colHeaders::Union{Nothing, Vector{String}} = nothing
rowHeaders::Union{Nothing, Vector{String}} = nothing
function APIUsageAggregatedOut(timeUnit, periodStart, periodEnd, totalUsage, historyTruncated, data, colHeaders, rowHeaders, )
OpenAPI.validate_property(APIUsageAggregatedOut, Symbol("timeUnit"), timeUnit)
OpenAPI.validate_property(APIUsageAggregatedOut, Symbol("periodStart"), periodStart)
OpenAPI.validate_property(APIUsageAggregatedOut, Symbol("periodEnd"), periodEnd)
OpenAPI.validate_property(APIUsageAggregatedOut, Symbol("totalUsage"), totalUsage)
OpenAPI.validate_property(APIUsageAggregatedOut, Symbol("historyTruncated"), historyTruncated)
OpenAPI.validate_property(APIUsageAggregatedOut, Symbol("data"), data)
OpenAPI.validate_property(APIUsageAggregatedOut, Symbol("colHeaders"), colHeaders)
OpenAPI.validate_property(APIUsageAggregatedOut, Symbol("rowHeaders"), rowHeaders)
return new(timeUnit, periodStart, periodEnd, totalUsage, historyTruncated, data, colHeaders, rowHeaders, )
end
end # type APIUsageAggregatedOut
const _property_types_APIUsageAggregatedOut = Dict{Symbol,String}(Symbol("timeUnit")=>"String", Symbol("periodStart")=>"Int64", Symbol("periodEnd")=>"Int64", Symbol("totalUsage")=>"Int64", Symbol("historyTruncated")=>"Bool", Symbol("data")=>"Vector{Vector{Int64}}", Symbol("colHeaders")=>"Vector{String}", Symbol("rowHeaders")=>"Vector{String}", )
OpenAPI.property_type(::Type{ APIUsageAggregatedOut }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_APIUsageAggregatedOut[name]))}
function check_required(o::APIUsageAggregatedOut)
true
end
function OpenAPI.validate_property(::Type{ APIUsageAggregatedOut }, name::Symbol, val)
if name === Symbol("periodStart")
OpenAPI.validate_param(name, "APIUsageAggregatedOut", :format, val, "int64")
end
if name === Symbol("periodEnd")
OpenAPI.validate_param(name, "APIUsageAggregatedOut", :format, val, "int64")
end
if name === Symbol("totalUsage")
OpenAPI.validate_param(name, "APIUsageAggregatedOut", :format, val, "int64")
end
end
| NamSor | https://github.com/NeroBlackstone/NamSor.jl.git |
|
[
"MIT"
] | 0.1.0 | 2d6ab091a1f4af72f40a76fe35b2c01982aa0bbf | code | 1154 | # This file was generated by the Julia OpenAPI Code Generator
# Do not modify this file directly. Modify the OpenAPI specification instead.
@doc raw"""APIUsageHistoryOut
APIUsageHistoryOut(;
detailedUsage=nothing,
)
- detailedUsage::Vector{APICounterV2Out} : Detailed usage as reported by the deduplicating API counter.
"""
Base.@kwdef mutable struct APIUsageHistoryOut <: OpenAPI.APIModel
detailedUsage::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{APICounterV2Out} }
function APIUsageHistoryOut(detailedUsage, )
OpenAPI.validate_property(APIUsageHistoryOut, Symbol("detailedUsage"), detailedUsage)
return new(detailedUsage, )
end
end # type APIUsageHistoryOut
const _property_types_APIUsageHistoryOut = Dict{Symbol,String}(Symbol("detailedUsage")=>"Vector{APICounterV2Out}", )
OpenAPI.property_type(::Type{ APIUsageHistoryOut }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_APIUsageHistoryOut[name]))}
function check_required(o::APIUsageHistoryOut)
true
end
function OpenAPI.validate_property(::Type{ APIUsageHistoryOut }, name::Symbol, val)
end
| NamSor | https://github.com/NeroBlackstone/NamSor.jl.git |
|
[
"MIT"
] | 0.1.0 | 2d6ab091a1f4af72f40a76fe35b2c01982aa0bbf | code | 1300 | # This file was generated by the Julia OpenAPI Code Generator
# Do not modify this file directly. Modify the OpenAPI specification instead.
@doc raw"""BatchCommunityEngageFullOut
BatchCommunityEngageFullOut(;
engagementCandidates=nothing,
)
- engagementCandidates::Vector{CommunityEngageOut} : Classified community engagement candidates
"""
Base.@kwdef mutable struct BatchCommunityEngageFullOut <: OpenAPI.APIModel
engagementCandidates::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{CommunityEngageOut} }
function BatchCommunityEngageFullOut(engagementCandidates, )
OpenAPI.validate_property(BatchCommunityEngageFullOut, Symbol("engagementCandidates"), engagementCandidates)
return new(engagementCandidates, )
end
end # type BatchCommunityEngageFullOut
const _property_types_BatchCommunityEngageFullOut = Dict{Symbol,String}(Symbol("engagementCandidates")=>"Vector{CommunityEngageOut}", )
OpenAPI.property_type(::Type{ BatchCommunityEngageFullOut }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_BatchCommunityEngageFullOut[name]))}
function check_required(o::BatchCommunityEngageFullOut)
true
end
function OpenAPI.validate_property(::Type{ BatchCommunityEngageFullOut }, name::Symbol, val)
end
| NamSor | https://github.com/NeroBlackstone/NamSor.jl.git |
|
[
"MIT"
] | 0.1.0 | 2d6ab091a1f4af72f40a76fe35b2c01982aa0bbf | code | 1256 | # This file was generated by the Julia OpenAPI Code Generator
# Do not modify this file directly. Modify the OpenAPI specification instead.
@doc raw"""BatchCommunityEngageOut
BatchCommunityEngageOut(;
engagementCandidates=nothing,
)
- engagementCandidates::Vector{CommunityEngageOut} : Classified community engagement candidates
"""
Base.@kwdef mutable struct BatchCommunityEngageOut <: OpenAPI.APIModel
engagementCandidates::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{CommunityEngageOut} }
function BatchCommunityEngageOut(engagementCandidates, )
OpenAPI.validate_property(BatchCommunityEngageOut, Symbol("engagementCandidates"), engagementCandidates)
return new(engagementCandidates, )
end
end # type BatchCommunityEngageOut
const _property_types_BatchCommunityEngageOut = Dict{Symbol,String}(Symbol("engagementCandidates")=>"Vector{CommunityEngageOut}", )
OpenAPI.property_type(::Type{ BatchCommunityEngageOut }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_BatchCommunityEngageOut[name]))}
function check_required(o::BatchCommunityEngageOut)
true
end
function OpenAPI.validate_property(::Type{ BatchCommunityEngageOut }, name::Symbol, val)
end
| NamSor | https://github.com/NeroBlackstone/NamSor.jl.git |
|
[
"MIT"
] | 0.1.0 | 2d6ab091a1f4af72f40a76fe35b2c01982aa0bbf | code | 1051 | # This file was generated by the Julia OpenAPI Code Generator
# Do not modify this file directly. Modify the OpenAPI specification instead.
@doc raw"""BatchCorridorIn
BatchCorridorIn(;
corridorFromTo=nothing,
)
- corridorFromTo::Vector{CorridorIn}
"""
Base.@kwdef mutable struct BatchCorridorIn <: OpenAPI.APIModel
corridorFromTo::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{CorridorIn} }
function BatchCorridorIn(corridorFromTo, )
OpenAPI.validate_property(BatchCorridorIn, Symbol("corridorFromTo"), corridorFromTo)
return new(corridorFromTo, )
end
end # type BatchCorridorIn
const _property_types_BatchCorridorIn = Dict{Symbol,String}(Symbol("corridorFromTo")=>"Vector{CorridorIn}", )
OpenAPI.property_type(::Type{ BatchCorridorIn }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_BatchCorridorIn[name]))}
function check_required(o::BatchCorridorIn)
true
end
function OpenAPI.validate_property(::Type{ BatchCorridorIn }, name::Symbol, val)
end
| NamSor | https://github.com/NeroBlackstone/NamSor.jl.git |
|
[
"MIT"
] | 0.1.0 | 2d6ab091a1f4af72f40a76fe35b2c01982aa0bbf | code | 1088 | # This file was generated by the Julia OpenAPI Code Generator
# Do not modify this file directly. Modify the OpenAPI specification instead.
@doc raw"""BatchCorridorOut
BatchCorridorOut(;
corridorFromTo=nothing,
)
- corridorFromTo::Vector{CorridorOut} : Classified corridors
"""
Base.@kwdef mutable struct BatchCorridorOut <: OpenAPI.APIModel
corridorFromTo::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{CorridorOut} }
function BatchCorridorOut(corridorFromTo, )
OpenAPI.validate_property(BatchCorridorOut, Symbol("corridorFromTo"), corridorFromTo)
return new(corridorFromTo, )
end
end # type BatchCorridorOut
const _property_types_BatchCorridorOut = Dict{Symbol,String}(Symbol("corridorFromTo")=>"Vector{CorridorOut}", )
OpenAPI.property_type(::Type{ BatchCorridorOut }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_BatchCorridorOut[name]))}
function check_required(o::BatchCorridorOut)
true
end
function OpenAPI.validate_property(::Type{ BatchCorridorOut }, name::Symbol, val)
end
| NamSor | https://github.com/NeroBlackstone/NamSor.jl.git |
|
[
"MIT"
] | 0.1.0 | 2d6ab091a1f4af72f40a76fe35b2c01982aa0bbf | code | 1309 | # This file was generated by the Julia OpenAPI Code Generator
# Do not modify this file directly. Modify the OpenAPI specification instead.
@doc raw"""BatchFirstLastNameCasteOut
Represents the output of inferring the LIKELY origin from a list of personal names.
BatchFirstLastNameCasteOut(;
personalNames=nothing,
)
- personalNames::Vector{FirstLastNameCasteOut} : Classified origined names
"""
Base.@kwdef mutable struct BatchFirstLastNameCasteOut <: OpenAPI.APIModel
personalNames::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{FirstLastNameCasteOut} }
function BatchFirstLastNameCasteOut(personalNames, )
OpenAPI.validate_property(BatchFirstLastNameCasteOut, Symbol("personalNames"), personalNames)
return new(personalNames, )
end
end # type BatchFirstLastNameCasteOut
const _property_types_BatchFirstLastNameCasteOut = Dict{Symbol,String}(Symbol("personalNames")=>"Vector{FirstLastNameCasteOut}", )
OpenAPI.property_type(::Type{ BatchFirstLastNameCasteOut }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_BatchFirstLastNameCasteOut[name]))}
function check_required(o::BatchFirstLastNameCasteOut)
true
end
function OpenAPI.validate_property(::Type{ BatchFirstLastNameCasteOut }, name::Symbol, val)
end
| NamSor | https://github.com/NeroBlackstone/NamSor.jl.git |
|
[
"MIT"
] | 0.1.0 | 2d6ab091a1f4af72f40a76fe35b2c01982aa0bbf | code | 1379 | # This file was generated by the Julia OpenAPI Code Generator
# Do not modify this file directly. Modify the OpenAPI specification instead.
@doc raw"""BatchFirstLastNameCastegroupOut
Represents the output of inferring the LIKELY origin from a list of personal names.
BatchFirstLastNameCastegroupOut(;
personalNames=nothing,
)
- personalNames::Vector{FirstLastNameCastegroupOut} : Classified origined names
"""
Base.@kwdef mutable struct BatchFirstLastNameCastegroupOut <: OpenAPI.APIModel
personalNames::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{FirstLastNameCastegroupOut} }
function BatchFirstLastNameCastegroupOut(personalNames, )
OpenAPI.validate_property(BatchFirstLastNameCastegroupOut, Symbol("personalNames"), personalNames)
return new(personalNames, )
end
end # type BatchFirstLastNameCastegroupOut
const _property_types_BatchFirstLastNameCastegroupOut = Dict{Symbol,String}(Symbol("personalNames")=>"Vector{FirstLastNameCastegroupOut}", )
OpenAPI.property_type(::Type{ BatchFirstLastNameCastegroupOut }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_BatchFirstLastNameCastegroupOut[name]))}
function check_required(o::BatchFirstLastNameCastegroupOut)
true
end
function OpenAPI.validate_property(::Type{ BatchFirstLastNameCastegroupOut }, name::Symbol, val)
end
| NamSor | https://github.com/NeroBlackstone/NamSor.jl.git |
|
[
"MIT"
] | 0.1.0 | 2d6ab091a1f4af72f40a76fe35b2c01982aa0bbf | code | 1404 | # This file was generated by the Julia OpenAPI Code Generator
# Do not modify this file directly. Modify the OpenAPI specification instead.
@doc raw"""BatchFirstLastNameDiasporaedOut
Represents the output of inferring the LIKELY ethnicity from a personal name, given an country of residence.
BatchFirstLastNameDiasporaedOut(;
personalNames=nothing,
)
- personalNames::Vector{FirstLastNameDiasporaedOut} : Classified diaspora names
"""
Base.@kwdef mutable struct BatchFirstLastNameDiasporaedOut <: OpenAPI.APIModel
personalNames::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{FirstLastNameDiasporaedOut} }
function BatchFirstLastNameDiasporaedOut(personalNames, )
OpenAPI.validate_property(BatchFirstLastNameDiasporaedOut, Symbol("personalNames"), personalNames)
return new(personalNames, )
end
end # type BatchFirstLastNameDiasporaedOut
const _property_types_BatchFirstLastNameDiasporaedOut = Dict{Symbol,String}(Symbol("personalNames")=>"Vector{FirstLastNameDiasporaedOut}", )
OpenAPI.property_type(::Type{ BatchFirstLastNameDiasporaedOut }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_BatchFirstLastNameDiasporaedOut[name]))}
function check_required(o::BatchFirstLastNameDiasporaedOut)
true
end
function OpenAPI.validate_property(::Type{ BatchFirstLastNameDiasporaedOut }, name::Symbol, val)
end
| NamSor | https://github.com/NeroBlackstone/NamSor.jl.git |
|
[
"MIT"
] | 0.1.0 | 2d6ab091a1f4af72f40a76fe35b2c01982aa0bbf | code | 1197 | # This file was generated by the Julia OpenAPI Code Generator
# Do not modify this file directly. Modify the OpenAPI specification instead.
@doc raw"""BatchFirstLastNameGenderIn
BatchFirstLastNameGenderIn(;
personalNames=nothing,
)
- personalNames::Vector{FirstLastNameGenderIn}
"""
Base.@kwdef mutable struct BatchFirstLastNameGenderIn <: OpenAPI.APIModel
personalNames::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{FirstLastNameGenderIn} }
function BatchFirstLastNameGenderIn(personalNames, )
OpenAPI.validate_property(BatchFirstLastNameGenderIn, Symbol("personalNames"), personalNames)
return new(personalNames, )
end
end # type BatchFirstLastNameGenderIn
const _property_types_BatchFirstLastNameGenderIn = Dict{Symbol,String}(Symbol("personalNames")=>"Vector{FirstLastNameGenderIn}", )
OpenAPI.property_type(::Type{ BatchFirstLastNameGenderIn }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_BatchFirstLastNameGenderIn[name]))}
function check_required(o::BatchFirstLastNameGenderIn)
true
end
function OpenAPI.validate_property(::Type{ BatchFirstLastNameGenderIn }, name::Symbol, val)
end
| NamSor | https://github.com/NeroBlackstone/NamSor.jl.git |
|
[
"MIT"
] | 0.1.0 | 2d6ab091a1f4af72f40a76fe35b2c01982aa0bbf | code | 1353 | # This file was generated by the Julia OpenAPI Code Generator
# Do not modify this file directly. Modify the OpenAPI specification instead.
@doc raw"""BatchFirstLastNameGenderedOut
Represents the output of inferring the LIKELY gender from a list of personal names.
BatchFirstLastNameGenderedOut(;
personalNames=nothing,
)
- personalNames::Vector{FirstLastNameGenderedOut} : Classified genderized names
"""
Base.@kwdef mutable struct BatchFirstLastNameGenderedOut <: OpenAPI.APIModel
personalNames::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{FirstLastNameGenderedOut} }
function BatchFirstLastNameGenderedOut(personalNames, )
OpenAPI.validate_property(BatchFirstLastNameGenderedOut, Symbol("personalNames"), personalNames)
return new(personalNames, )
end
end # type BatchFirstLastNameGenderedOut
const _property_types_BatchFirstLastNameGenderedOut = Dict{Symbol,String}(Symbol("personalNames")=>"Vector{FirstLastNameGenderedOut}", )
OpenAPI.property_type(::Type{ BatchFirstLastNameGenderedOut }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_BatchFirstLastNameGenderedOut[name]))}
function check_required(o::BatchFirstLastNameGenderedOut)
true
end
function OpenAPI.validate_property(::Type{ BatchFirstLastNameGenderedOut }, name::Symbol, val)
end
| NamSor | https://github.com/NeroBlackstone/NamSor.jl.git |
|
[
"MIT"
] | 0.1.0 | 2d6ab091a1f4af72f40a76fe35b2c01982aa0bbf | code | 1155 | # This file was generated by the Julia OpenAPI Code Generator
# Do not modify this file directly. Modify the OpenAPI specification instead.
@doc raw"""BatchFirstLastNameGeoIn
BatchFirstLastNameGeoIn(;
personalNames=nothing,
)
- personalNames::Vector{FirstLastNameGeoIn}
"""
Base.@kwdef mutable struct BatchFirstLastNameGeoIn <: OpenAPI.APIModel
personalNames::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{FirstLastNameGeoIn} }
function BatchFirstLastNameGeoIn(personalNames, )
OpenAPI.validate_property(BatchFirstLastNameGeoIn, Symbol("personalNames"), personalNames)
return new(personalNames, )
end
end # type BatchFirstLastNameGeoIn
const _property_types_BatchFirstLastNameGeoIn = Dict{Symbol,String}(Symbol("personalNames")=>"Vector{FirstLastNameGeoIn}", )
OpenAPI.property_type(::Type{ BatchFirstLastNameGeoIn }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_BatchFirstLastNameGeoIn[name]))}
function check_required(o::BatchFirstLastNameGeoIn)
true
end
function OpenAPI.validate_property(::Type{ BatchFirstLastNameGeoIn }, name::Symbol, val)
end
| NamSor | https://github.com/NeroBlackstone/NamSor.jl.git |
|
[
"MIT"
] | 0.1.0 | 2d6ab091a1f4af72f40a76fe35b2c01982aa0bbf | code | 1188 | # This file was generated by the Julia OpenAPI Code Generator
# Do not modify this file directly. Modify the OpenAPI specification instead.
@doc raw"""BatchFirstLastNameGeoOut
BatchFirstLastNameGeoOut(;
personalNames=nothing,
)
- personalNames::Vector{FirstLastNameGeoOut} : Classified names
"""
Base.@kwdef mutable struct BatchFirstLastNameGeoOut <: OpenAPI.APIModel
personalNames::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{FirstLastNameGeoOut} }
function BatchFirstLastNameGeoOut(personalNames, )
OpenAPI.validate_property(BatchFirstLastNameGeoOut, Symbol("personalNames"), personalNames)
return new(personalNames, )
end
end # type BatchFirstLastNameGeoOut
const _property_types_BatchFirstLastNameGeoOut = Dict{Symbol,String}(Symbol("personalNames")=>"Vector{FirstLastNameGeoOut}", )
OpenAPI.property_type(::Type{ BatchFirstLastNameGeoOut }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_BatchFirstLastNameGeoOut[name]))}
function check_required(o::BatchFirstLastNameGeoOut)
true
end
function OpenAPI.validate_property(::Type{ BatchFirstLastNameGeoOut }, name::Symbol, val)
end
| NamSor | https://github.com/NeroBlackstone/NamSor.jl.git |
|
[
"MIT"
] | 0.1.0 | 2d6ab091a1f4af72f40a76fe35b2c01982aa0bbf | code | 1555 | # This file was generated by the Julia OpenAPI Code Generator
# Do not modify this file directly. Modify the OpenAPI specification instead.
@doc raw"""BatchFirstLastNameGeoSubclassificationOut
Represents the output of inferring the LIKELY country subclassification (regional names).
BatchFirstLastNameGeoSubclassificationOut(;
personalNames=nothing,
)
- personalNames::Vector{FirstLastNameGeoSubclassificationOut} : Classified names at sub country level (region or state)
"""
Base.@kwdef mutable struct BatchFirstLastNameGeoSubclassificationOut <: OpenAPI.APIModel
personalNames::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{FirstLastNameGeoSubclassificationOut} }
function BatchFirstLastNameGeoSubclassificationOut(personalNames, )
OpenAPI.validate_property(BatchFirstLastNameGeoSubclassificationOut, Symbol("personalNames"), personalNames)
return new(personalNames, )
end
end # type BatchFirstLastNameGeoSubclassificationOut
const _property_types_BatchFirstLastNameGeoSubclassificationOut = Dict{Symbol,String}(Symbol("personalNames")=>"Vector{FirstLastNameGeoSubclassificationOut}", )
OpenAPI.property_type(::Type{ BatchFirstLastNameGeoSubclassificationOut }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_BatchFirstLastNameGeoSubclassificationOut[name]))}
function check_required(o::BatchFirstLastNameGeoSubclassificationOut)
true
end
function OpenAPI.validate_property(::Type{ BatchFirstLastNameGeoSubclassificationOut }, name::Symbol, val)
end
| NamSor | https://github.com/NeroBlackstone/NamSor.jl.git |
|
[
"MIT"
] | 0.1.0 | 2d6ab091a1f4af72f40a76fe35b2c01982aa0bbf | code | 1309 | # This file was generated by the Julia OpenAPI Code Generator
# Do not modify this file directly. Modify the OpenAPI specification instead.
@doc raw"""BatchFirstLastNameGeoSubdivisionIn
BatchFirstLastNameGeoSubdivisionIn(;
personalNames=nothing,
)
- personalNames::Vector{FirstLastNameGeoSubdivisionIn}
"""
Base.@kwdef mutable struct BatchFirstLastNameGeoSubdivisionIn <: OpenAPI.APIModel
personalNames::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{FirstLastNameGeoSubdivisionIn} }
function BatchFirstLastNameGeoSubdivisionIn(personalNames, )
OpenAPI.validate_property(BatchFirstLastNameGeoSubdivisionIn, Symbol("personalNames"), personalNames)
return new(personalNames, )
end
end # type BatchFirstLastNameGeoSubdivisionIn
const _property_types_BatchFirstLastNameGeoSubdivisionIn = Dict{Symbol,String}(Symbol("personalNames")=>"Vector{FirstLastNameGeoSubdivisionIn}", )
OpenAPI.property_type(::Type{ BatchFirstLastNameGeoSubdivisionIn }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_BatchFirstLastNameGeoSubdivisionIn[name]))}
function check_required(o::BatchFirstLastNameGeoSubdivisionIn)
true
end
function OpenAPI.validate_property(::Type{ BatchFirstLastNameGeoSubdivisionIn }, name::Symbol, val)
end
| NamSor | https://github.com/NeroBlackstone/NamSor.jl.git |
|
[
"MIT"
] | 0.1.0 | 2d6ab091a1f4af72f40a76fe35b2c01982aa0bbf | code | 1239 | # This file was generated by the Julia OpenAPI Code Generator
# Do not modify this file directly. Modify the OpenAPI specification instead.
@doc raw"""BatchFirstLastNameGeoZippedIn
BatchFirstLastNameGeoZippedIn(;
personalNames=nothing,
)
- personalNames::Vector{FirstLastNameGeoZippedIn}
"""
Base.@kwdef mutable struct BatchFirstLastNameGeoZippedIn <: OpenAPI.APIModel
personalNames::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{FirstLastNameGeoZippedIn} }
function BatchFirstLastNameGeoZippedIn(personalNames, )
OpenAPI.validate_property(BatchFirstLastNameGeoZippedIn, Symbol("personalNames"), personalNames)
return new(personalNames, )
end
end # type BatchFirstLastNameGeoZippedIn
const _property_types_BatchFirstLastNameGeoZippedIn = Dict{Symbol,String}(Symbol("personalNames")=>"Vector{FirstLastNameGeoZippedIn}", )
OpenAPI.property_type(::Type{ BatchFirstLastNameGeoZippedIn }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_BatchFirstLastNameGeoZippedIn[name]))}
function check_required(o::BatchFirstLastNameGeoZippedIn)
true
end
function OpenAPI.validate_property(::Type{ BatchFirstLastNameGeoZippedIn }, name::Symbol, val)
end
| NamSor | https://github.com/NeroBlackstone/NamSor.jl.git |
|
[
"MIT"
] | 0.1.0 | 2d6ab091a1f4af72f40a76fe35b2c01982aa0bbf | code | 1113 | # This file was generated by the Julia OpenAPI Code Generator
# Do not modify this file directly. Modify the OpenAPI specification instead.
@doc raw"""BatchFirstLastNameIn
BatchFirstLastNameIn(;
personalNames=nothing,
)
- personalNames::Vector{FirstLastNameIn}
"""
Base.@kwdef mutable struct BatchFirstLastNameIn <: OpenAPI.APIModel
personalNames::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{FirstLastNameIn} }
function BatchFirstLastNameIn(personalNames, )
OpenAPI.validate_property(BatchFirstLastNameIn, Symbol("personalNames"), personalNames)
return new(personalNames, )
end
end # type BatchFirstLastNameIn
const _property_types_BatchFirstLastNameIn = Dict{Symbol,String}(Symbol("personalNames")=>"Vector{FirstLastNameIn}", )
OpenAPI.property_type(::Type{ BatchFirstLastNameIn }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_BatchFirstLastNameIn[name]))}
function check_required(o::BatchFirstLastNameIn)
true
end
function OpenAPI.validate_property(::Type{ BatchFirstLastNameIn }, name::Symbol, val)
end
| NamSor | https://github.com/NeroBlackstone/NamSor.jl.git |
|
[
"MIT"
] | 0.1.0 | 2d6ab091a1f4af72f40a76fe35b2c01982aa0bbf | code | 1351 | # This file was generated by the Julia OpenAPI Code Generator
# Do not modify this file directly. Modify the OpenAPI specification instead.
@doc raw"""BatchFirstLastNameOriginedOut
Represents the output of inferring the LIKELY origin from a list of personal names.
BatchFirstLastNameOriginedOut(;
personalNames=nothing,
)
- personalNames::Vector{FirstLastNameOriginedOut} : Classified origined names
"""
Base.@kwdef mutable struct BatchFirstLastNameOriginedOut <: OpenAPI.APIModel
personalNames::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{FirstLastNameOriginedOut} }
function BatchFirstLastNameOriginedOut(personalNames, )
OpenAPI.validate_property(BatchFirstLastNameOriginedOut, Symbol("personalNames"), personalNames)
return new(personalNames, )
end
end # type BatchFirstLastNameOriginedOut
const _property_types_BatchFirstLastNameOriginedOut = Dict{Symbol,String}(Symbol("personalNames")=>"Vector{FirstLastNameOriginedOut}", )
OpenAPI.property_type(::Type{ BatchFirstLastNameOriginedOut }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_BatchFirstLastNameOriginedOut[name]))}
function check_required(o::BatchFirstLastNameOriginedOut)
true
end
function OpenAPI.validate_property(::Type{ BatchFirstLastNameOriginedOut }, name::Symbol, val)
end
| NamSor | https://github.com/NeroBlackstone/NamSor.jl.git |
|
[
"MIT"
] | 0.1.0 | 2d6ab091a1f4af72f40a76fe35b2c01982aa0bbf | code | 1521 | # This file was generated by the Julia OpenAPI Code Generator
# Do not modify this file directly. Modify the OpenAPI specification instead.
@doc raw"""BatchFirstLastNamePhoneCodedOut
Represents the output of inferring the LIKELY country and phone code of personal names+phones.
BatchFirstLastNamePhoneCodedOut(;
personalNamesWithPhoneNumbers=nothing,
)
- personalNamesWithPhoneNumbers::Vector{FirstLastNamePhoneCodedOut} : Classified phone-coded names
"""
Base.@kwdef mutable struct BatchFirstLastNamePhoneCodedOut <: OpenAPI.APIModel
personalNamesWithPhoneNumbers::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{FirstLastNamePhoneCodedOut} }
function BatchFirstLastNamePhoneCodedOut(personalNamesWithPhoneNumbers, )
OpenAPI.validate_property(BatchFirstLastNamePhoneCodedOut, Symbol("personalNamesWithPhoneNumbers"), personalNamesWithPhoneNumbers)
return new(personalNamesWithPhoneNumbers, )
end
end # type BatchFirstLastNamePhoneCodedOut
const _property_types_BatchFirstLastNamePhoneCodedOut = Dict{Symbol,String}(Symbol("personalNamesWithPhoneNumbers")=>"Vector{FirstLastNamePhoneCodedOut}", )
OpenAPI.property_type(::Type{ BatchFirstLastNamePhoneCodedOut }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_BatchFirstLastNamePhoneCodedOut[name]))}
function check_required(o::BatchFirstLastNamePhoneCodedOut)
true
end
function OpenAPI.validate_property(::Type{ BatchFirstLastNamePhoneCodedOut }, name::Symbol, val)
end
| NamSor | https://github.com/NeroBlackstone/NamSor.jl.git |
|
[
"MIT"
] | 0.1.0 | 2d6ab091a1f4af72f40a76fe35b2c01982aa0bbf | code | 1437 | # This file was generated by the Julia OpenAPI Code Generator
# Do not modify this file directly. Modify the OpenAPI specification instead.
@doc raw"""BatchFirstLastNamePhoneNumberGeoIn
BatchFirstLastNamePhoneNumberGeoIn(;
personalNamesWithPhoneNumbers=nothing,
)
- personalNamesWithPhoneNumbers::Vector{FirstLastNamePhoneNumberGeoIn}
"""
Base.@kwdef mutable struct BatchFirstLastNamePhoneNumberGeoIn <: OpenAPI.APIModel
personalNamesWithPhoneNumbers::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{FirstLastNamePhoneNumberGeoIn} }
function BatchFirstLastNamePhoneNumberGeoIn(personalNamesWithPhoneNumbers, )
OpenAPI.validate_property(BatchFirstLastNamePhoneNumberGeoIn, Symbol("personalNamesWithPhoneNumbers"), personalNamesWithPhoneNumbers)
return new(personalNamesWithPhoneNumbers, )
end
end # type BatchFirstLastNamePhoneNumberGeoIn
const _property_types_BatchFirstLastNamePhoneNumberGeoIn = Dict{Symbol,String}(Symbol("personalNamesWithPhoneNumbers")=>"Vector{FirstLastNamePhoneNumberGeoIn}", )
OpenAPI.property_type(::Type{ BatchFirstLastNamePhoneNumberGeoIn }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_BatchFirstLastNamePhoneNumberGeoIn[name]))}
function check_required(o::BatchFirstLastNamePhoneNumberGeoIn)
true
end
function OpenAPI.validate_property(::Type{ BatchFirstLastNamePhoneNumberGeoIn }, name::Symbol, val)
end
| NamSor | https://github.com/NeroBlackstone/NamSor.jl.git |
|
[
"MIT"
] | 0.1.0 | 2d6ab091a1f4af72f40a76fe35b2c01982aa0bbf | code | 1395 | # This file was generated by the Julia OpenAPI Code Generator
# Do not modify this file directly. Modify the OpenAPI specification instead.
@doc raw"""BatchFirstLastNamePhoneNumberIn
BatchFirstLastNamePhoneNumberIn(;
personalNamesWithPhoneNumbers=nothing,
)
- personalNamesWithPhoneNumbers::Vector{FirstLastNamePhoneNumberIn}
"""
Base.@kwdef mutable struct BatchFirstLastNamePhoneNumberIn <: OpenAPI.APIModel
personalNamesWithPhoneNumbers::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{FirstLastNamePhoneNumberIn} }
function BatchFirstLastNamePhoneNumberIn(personalNamesWithPhoneNumbers, )
OpenAPI.validate_property(BatchFirstLastNamePhoneNumberIn, Symbol("personalNamesWithPhoneNumbers"), personalNamesWithPhoneNumbers)
return new(personalNamesWithPhoneNumbers, )
end
end # type BatchFirstLastNamePhoneNumberIn
const _property_types_BatchFirstLastNamePhoneNumberIn = Dict{Symbol,String}(Symbol("personalNamesWithPhoneNumbers")=>"Vector{FirstLastNamePhoneNumberIn}", )
OpenAPI.property_type(::Type{ BatchFirstLastNamePhoneNumberIn }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_BatchFirstLastNamePhoneNumberIn[name]))}
function check_required(o::BatchFirstLastNamePhoneNumberIn)
true
end
function OpenAPI.validate_property(::Type{ BatchFirstLastNamePhoneNumberIn }, name::Symbol, val)
end
| NamSor | https://github.com/NeroBlackstone/NamSor.jl.git |
|
[
"MIT"
] | 0.1.0 | 2d6ab091a1f4af72f40a76fe35b2c01982aa0bbf | code | 1372 | # This file was generated by the Julia OpenAPI Code Generator
# Do not modify this file directly. Modify the OpenAPI specification instead.
@doc raw"""BatchFirstLastNameReligionedOut
Represents the output of inferring the LIKELY religion from a list of personal names.
BatchFirstLastNameReligionedOut(;
personalNames=nothing,
)
- personalNames::Vector{FirstLastNameReligionedOut} : Classified names
"""
Base.@kwdef mutable struct BatchFirstLastNameReligionedOut <: OpenAPI.APIModel
personalNames::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{FirstLastNameReligionedOut} }
function BatchFirstLastNameReligionedOut(personalNames, )
OpenAPI.validate_property(BatchFirstLastNameReligionedOut, Symbol("personalNames"), personalNames)
return new(personalNames, )
end
end # type BatchFirstLastNameReligionedOut
const _property_types_BatchFirstLastNameReligionedOut = Dict{Symbol,String}(Symbol("personalNames")=>"Vector{FirstLastNameReligionedOut}", )
OpenAPI.property_type(::Type{ BatchFirstLastNameReligionedOut }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_BatchFirstLastNameReligionedOut[name]))}
function check_required(o::BatchFirstLastNameReligionedOut)
true
end
function OpenAPI.validate_property(::Type{ BatchFirstLastNameReligionedOut }, name::Symbol, val)
end
| NamSor | https://github.com/NeroBlackstone/NamSor.jl.git |
|
[
"MIT"
] | 0.1.0 | 2d6ab091a1f4af72f40a76fe35b2c01982aa0bbf | code | 1267 | # This file was generated by the Julia OpenAPI Code Generator
# Do not modify this file directly. Modify the OpenAPI specification instead.
@doc raw"""BatchFirstLastNameSubdivisionIn
BatchFirstLastNameSubdivisionIn(;
personalNames=nothing,
)
- personalNames::Vector{FirstLastNameSubdivisionIn}
"""
Base.@kwdef mutable struct BatchFirstLastNameSubdivisionIn <: OpenAPI.APIModel
personalNames::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{FirstLastNameSubdivisionIn} }
function BatchFirstLastNameSubdivisionIn(personalNames, )
OpenAPI.validate_property(BatchFirstLastNameSubdivisionIn, Symbol("personalNames"), personalNames)
return new(personalNames, )
end
end # type BatchFirstLastNameSubdivisionIn
const _property_types_BatchFirstLastNameSubdivisionIn = Dict{Symbol,String}(Symbol("personalNames")=>"Vector{FirstLastNameSubdivisionIn}", )
OpenAPI.property_type(::Type{ BatchFirstLastNameSubdivisionIn }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_BatchFirstLastNameSubdivisionIn[name]))}
function check_required(o::BatchFirstLastNameSubdivisionIn)
true
end
function OpenAPI.validate_property(::Type{ BatchFirstLastNameSubdivisionIn }, name::Symbol, val)
end
| NamSor | https://github.com/NeroBlackstone/NamSor.jl.git |
|
[
"MIT"
] | 0.1.0 | 2d6ab091a1f4af72f40a76fe35b2c01982aa0bbf | code | 1541 | # This file was generated by the Julia OpenAPI Code Generator
# Do not modify this file directly. Modify the OpenAPI specification instead.
@doc raw"""BatchFirstLastNameUSRaceEthnicityOut
Represents the output of inferring the LIKELY US 'race/ethnicity' from a personal name, given US country of residence and (optionally) a ZIP5 code.
BatchFirstLastNameUSRaceEthnicityOut(;
personalNames=nothing,
)
- personalNames::Vector{FirstLastNameUSRaceEthnicityOut} : Classified US 'race'/ethnicized names
"""
Base.@kwdef mutable struct BatchFirstLastNameUSRaceEthnicityOut <: OpenAPI.APIModel
personalNames::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{FirstLastNameUSRaceEthnicityOut} }
function BatchFirstLastNameUSRaceEthnicityOut(personalNames, )
OpenAPI.validate_property(BatchFirstLastNameUSRaceEthnicityOut, Symbol("personalNames"), personalNames)
return new(personalNames, )
end
end # type BatchFirstLastNameUSRaceEthnicityOut
const _property_types_BatchFirstLastNameUSRaceEthnicityOut = Dict{Symbol,String}(Symbol("personalNames")=>"Vector{FirstLastNameUSRaceEthnicityOut}", )
OpenAPI.property_type(::Type{ BatchFirstLastNameUSRaceEthnicityOut }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_BatchFirstLastNameUSRaceEthnicityOut[name]))}
function check_required(o::BatchFirstLastNameUSRaceEthnicityOut)
true
end
function OpenAPI.validate_property(::Type{ BatchFirstLastNameUSRaceEthnicityOut }, name::Symbol, val)
end
| NamSor | https://github.com/NeroBlackstone/NamSor.jl.git |
|
[
"MIT"
] | 0.1.0 | 2d6ab091a1f4af72f40a76fe35b2c01982aa0bbf | code | 1295 | # This file was generated by the Julia OpenAPI Code Generator
# Do not modify this file directly. Modify the OpenAPI specification instead.
@doc raw"""BatchMatchPersonalFirstLastNameIn
BatchMatchPersonalFirstLastNameIn(;
personalNames=nothing,
)
- personalNames::Vector{MatchPersonalFirstLastNameIn}
"""
Base.@kwdef mutable struct BatchMatchPersonalFirstLastNameIn <: OpenAPI.APIModel
personalNames::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{MatchPersonalFirstLastNameIn} }
function BatchMatchPersonalFirstLastNameIn(personalNames, )
OpenAPI.validate_property(BatchMatchPersonalFirstLastNameIn, Symbol("personalNames"), personalNames)
return new(personalNames, )
end
end # type BatchMatchPersonalFirstLastNameIn
const _property_types_BatchMatchPersonalFirstLastNameIn = Dict{Symbol,String}(Symbol("personalNames")=>"Vector{MatchPersonalFirstLastNameIn}", )
OpenAPI.property_type(::Type{ BatchMatchPersonalFirstLastNameIn }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_BatchMatchPersonalFirstLastNameIn[name]))}
function check_required(o::BatchMatchPersonalFirstLastNameIn)
true
end
function OpenAPI.validate_property(::Type{ BatchMatchPersonalFirstLastNameIn }, name::Symbol, val)
end
| NamSor | https://github.com/NeroBlackstone/NamSor.jl.git |
|
[
"MIT"
] | 0.1.0 | 2d6ab091a1f4af72f40a76fe35b2c01982aa0bbf | code | 1013 | # This file was generated by the Julia OpenAPI Code Generator
# Do not modify this file directly. Modify the OpenAPI specification instead.
@doc raw"""BatchNameGeoIn
BatchNameGeoIn(;
properNouns=nothing,
)
- properNouns::Vector{NameGeoIn}
"""
Base.@kwdef mutable struct BatchNameGeoIn <: OpenAPI.APIModel
properNouns::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{NameGeoIn} }
function BatchNameGeoIn(properNouns, )
OpenAPI.validate_property(BatchNameGeoIn, Symbol("properNouns"), properNouns)
return new(properNouns, )
end
end # type BatchNameGeoIn
const _property_types_BatchNameGeoIn = Dict{Symbol,String}(Symbol("properNouns")=>"Vector{NameGeoIn}", )
OpenAPI.property_type(::Type{ BatchNameGeoIn }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_BatchNameGeoIn[name]))}
function check_required(o::BatchNameGeoIn)
true
end
function OpenAPI.validate_property(::Type{ BatchNameGeoIn }, name::Symbol, val)
end
| NamSor | https://github.com/NeroBlackstone/NamSor.jl.git |
|
[
"MIT"
] | 0.1.0 | 2d6ab091a1f4af72f40a76fe35b2c01982aa0bbf | code | 971 | # This file was generated by the Julia OpenAPI Code Generator
# Do not modify this file directly. Modify the OpenAPI specification instead.
@doc raw"""BatchNameIn
BatchNameIn(;
properNouns=nothing,
)
- properNouns::Vector{NameIn}
"""
Base.@kwdef mutable struct BatchNameIn <: OpenAPI.APIModel
properNouns::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{NameIn} }
function BatchNameIn(properNouns, )
OpenAPI.validate_property(BatchNameIn, Symbol("properNouns"), properNouns)
return new(properNouns, )
end
end # type BatchNameIn
const _property_types_BatchNameIn = Dict{Symbol,String}(Symbol("properNouns")=>"Vector{NameIn}", )
OpenAPI.property_type(::Type{ BatchNameIn }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_BatchNameIn[name]))}
function check_required(o::BatchNameIn)
true
end
function OpenAPI.validate_property(::Type{ BatchNameIn }, name::Symbol, val)
end
| NamSor | https://github.com/NeroBlackstone/NamSor.jl.git |
|
[
"MIT"
] | 0.1.0 | 2d6ab091a1f4af72f40a76fe35b2c01982aa0bbf | code | 1318 | # This file was generated by the Julia OpenAPI Code Generator
# Do not modify this file directly. Modify the OpenAPI specification instead.
@doc raw"""BatchNameMatchCandidatesOut
BatchNameMatchCandidatesOut(;
namesAndMatchCandidates=nothing,
)
- namesAndMatchCandidates::Vector{NameMatchCandidatesOut} : Classified matched names
"""
Base.@kwdef mutable struct BatchNameMatchCandidatesOut <: OpenAPI.APIModel
namesAndMatchCandidates::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{NameMatchCandidatesOut} }
function BatchNameMatchCandidatesOut(namesAndMatchCandidates, )
OpenAPI.validate_property(BatchNameMatchCandidatesOut, Symbol("namesAndMatchCandidates"), namesAndMatchCandidates)
return new(namesAndMatchCandidates, )
end
end # type BatchNameMatchCandidatesOut
const _property_types_BatchNameMatchCandidatesOut = Dict{Symbol,String}(Symbol("namesAndMatchCandidates")=>"Vector{NameMatchCandidatesOut}", )
OpenAPI.property_type(::Type{ BatchNameMatchCandidatesOut }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_BatchNameMatchCandidatesOut[name]))}
function check_required(o::BatchNameMatchCandidatesOut)
true
end
function OpenAPI.validate_property(::Type{ BatchNameMatchCandidatesOut }, name::Symbol, val)
end
| NamSor | https://github.com/NeroBlackstone/NamSor.jl.git |
|
[
"MIT"
] | 0.1.0 | 2d6ab091a1f4af72f40a76fe35b2c01982aa0bbf | code | 1118 | # This file was generated by the Julia OpenAPI Code Generator
# Do not modify this file directly. Modify the OpenAPI specification instead.
@doc raw"""BatchNameMatchedOut
BatchNameMatchedOut(;
matchedNames=nothing,
)
- matchedNames::Vector{NameMatchedOut} : Classified matched names
"""
Base.@kwdef mutable struct BatchNameMatchedOut <: OpenAPI.APIModel
matchedNames::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{NameMatchedOut} }
function BatchNameMatchedOut(matchedNames, )
OpenAPI.validate_property(BatchNameMatchedOut, Symbol("matchedNames"), matchedNames)
return new(matchedNames, )
end
end # type BatchNameMatchedOut
const _property_types_BatchNameMatchedOut = Dict{Symbol,String}(Symbol("matchedNames")=>"Vector{NameMatchedOut}", )
OpenAPI.property_type(::Type{ BatchNameMatchedOut }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_BatchNameMatchedOut[name]))}
function check_required(o::BatchNameMatchedOut)
true
end
function OpenAPI.validate_property(::Type{ BatchNameMatchedOut }, name::Symbol, val)
end
| NamSor | https://github.com/NeroBlackstone/NamSor.jl.git |
|
[
"MIT"
] | 0.1.0 | 2d6ab091a1f4af72f40a76fe35b2c01982aa0bbf | code | 1279 | # This file was generated by the Julia OpenAPI Code Generator
# Do not modify this file directly. Modify the OpenAPI specification instead.
@doc raw"""BatchPersonalNameCastegroupOut
BatchPersonalNameCastegroupOut(;
personalNames=nothing,
)
- personalNames::Vector{PersonalNameCastegroupOut} : Caste group-coded names
"""
Base.@kwdef mutable struct BatchPersonalNameCastegroupOut <: OpenAPI.APIModel
personalNames::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{PersonalNameCastegroupOut} }
function BatchPersonalNameCastegroupOut(personalNames, )
OpenAPI.validate_property(BatchPersonalNameCastegroupOut, Symbol("personalNames"), personalNames)
return new(personalNames, )
end
end # type BatchPersonalNameCastegroupOut
const _property_types_BatchPersonalNameCastegroupOut = Dict{Symbol,String}(Symbol("personalNames")=>"Vector{PersonalNameCastegroupOut}", )
OpenAPI.property_type(::Type{ BatchPersonalNameCastegroupOut }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_BatchPersonalNameCastegroupOut[name]))}
function check_required(o::BatchPersonalNameCastegroupOut)
true
end
function OpenAPI.validate_property(::Type{ BatchPersonalNameCastegroupOut }, name::Symbol, val)
end
| NamSor | https://github.com/NeroBlackstone/NamSor.jl.git |
|
[
"MIT"
] | 0.1.0 | 2d6ab091a1f4af72f40a76fe35b2c01982aa0bbf | code | 1390 | # This file was generated by the Julia OpenAPI Code Generator
# Do not modify this file directly. Modify the OpenAPI specification instead.
@doc raw"""BatchPersonalNameDiasporaedOut
Represents the output of inferring the LIKELY ethnicity from a personal name, given an country of residence.
BatchPersonalNameDiasporaedOut(;
personalNames=nothing,
)
- personalNames::Vector{PersonalNameDiasporaedOut} : Classified diaspora names
"""
Base.@kwdef mutable struct BatchPersonalNameDiasporaedOut <: OpenAPI.APIModel
personalNames::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{PersonalNameDiasporaedOut} }
function BatchPersonalNameDiasporaedOut(personalNames, )
OpenAPI.validate_property(BatchPersonalNameDiasporaedOut, Symbol("personalNames"), personalNames)
return new(personalNames, )
end
end # type BatchPersonalNameDiasporaedOut
const _property_types_BatchPersonalNameDiasporaedOut = Dict{Symbol,String}(Symbol("personalNames")=>"Vector{PersonalNameDiasporaedOut}", )
OpenAPI.property_type(::Type{ BatchPersonalNameDiasporaedOut }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_BatchPersonalNameDiasporaedOut[name]))}
function check_required(o::BatchPersonalNameDiasporaedOut)
true
end
function OpenAPI.validate_property(::Type{ BatchPersonalNameDiasporaedOut }, name::Symbol, val)
end
| NamSor | https://github.com/NeroBlackstone/NamSor.jl.git |
|
[
"MIT"
] | 0.1.0 | 2d6ab091a1f4af72f40a76fe35b2c01982aa0bbf | code | 1255 | # This file was generated by the Julia OpenAPI Code Generator
# Do not modify this file directly. Modify the OpenAPI specification instead.
@doc raw"""BatchPersonalNameGenderedOut
BatchPersonalNameGenderedOut(;
personalNames=nothing,
)
- personalNames::Vector{PersonalNameGenderedOut} : Classified genderized names
"""
Base.@kwdef mutable struct BatchPersonalNameGenderedOut <: OpenAPI.APIModel
personalNames::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{PersonalNameGenderedOut} }
function BatchPersonalNameGenderedOut(personalNames, )
OpenAPI.validate_property(BatchPersonalNameGenderedOut, Symbol("personalNames"), personalNames)
return new(personalNames, )
end
end # type BatchPersonalNameGenderedOut
const _property_types_BatchPersonalNameGenderedOut = Dict{Symbol,String}(Symbol("personalNames")=>"Vector{PersonalNameGenderedOut}", )
OpenAPI.property_type(::Type{ BatchPersonalNameGenderedOut }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_BatchPersonalNameGenderedOut[name]))}
function check_required(o::BatchPersonalNameGenderedOut)
true
end
function OpenAPI.validate_property(::Type{ BatchPersonalNameGenderedOut }, name::Symbol, val)
end
| NamSor | https://github.com/NeroBlackstone/NamSor.jl.git |
|
[
"MIT"
] | 0.1.0 | 2d6ab091a1f4af72f40a76fe35b2c01982aa0bbf | code | 1141 | # This file was generated by the Julia OpenAPI Code Generator
# Do not modify this file directly. Modify the OpenAPI specification instead.
@doc raw"""BatchPersonalNameGeoIn
BatchPersonalNameGeoIn(;
personalNames=nothing,
)
- personalNames::Vector{PersonalNameGeoIn}
"""
Base.@kwdef mutable struct BatchPersonalNameGeoIn <: OpenAPI.APIModel
personalNames::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{PersonalNameGeoIn} }
function BatchPersonalNameGeoIn(personalNames, )
OpenAPI.validate_property(BatchPersonalNameGeoIn, Symbol("personalNames"), personalNames)
return new(personalNames, )
end
end # type BatchPersonalNameGeoIn
const _property_types_BatchPersonalNameGeoIn = Dict{Symbol,String}(Symbol("personalNames")=>"Vector{PersonalNameGeoIn}", )
OpenAPI.property_type(::Type{ BatchPersonalNameGeoIn }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_BatchPersonalNameGeoIn[name]))}
function check_required(o::BatchPersonalNameGeoIn)
true
end
function OpenAPI.validate_property(::Type{ BatchPersonalNameGeoIn }, name::Symbol, val)
end
| NamSor | https://github.com/NeroBlackstone/NamSor.jl.git |
|
[
"MIT"
] | 0.1.0 | 2d6ab091a1f4af72f40a76fe35b2c01982aa0bbf | code | 1178 | # This file was generated by the Julia OpenAPI Code Generator
# Do not modify this file directly. Modify the OpenAPI specification instead.
@doc raw"""BatchPersonalNameGeoOut
BatchPersonalNameGeoOut(;
personalNames=nothing,
)
- personalNames::Vector{PersonalNameGeoOut} : Classified geo names
"""
Base.@kwdef mutable struct BatchPersonalNameGeoOut <: OpenAPI.APIModel
personalNames::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{PersonalNameGeoOut} }
function BatchPersonalNameGeoOut(personalNames, )
OpenAPI.validate_property(BatchPersonalNameGeoOut, Symbol("personalNames"), personalNames)
return new(personalNames, )
end
end # type BatchPersonalNameGeoOut
const _property_types_BatchPersonalNameGeoOut = Dict{Symbol,String}(Symbol("personalNames")=>"Vector{PersonalNameGeoOut}", )
OpenAPI.property_type(::Type{ BatchPersonalNameGeoOut }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_BatchPersonalNameGeoOut[name]))}
function check_required(o::BatchPersonalNameGeoOut)
true
end
function OpenAPI.validate_property(::Type{ BatchPersonalNameGeoOut }, name::Symbol, val)
end
| NamSor | https://github.com/NeroBlackstone/NamSor.jl.git |
|
[
"MIT"
] | 0.1.0 | 2d6ab091a1f4af72f40a76fe35b2c01982aa0bbf | code | 1541 | # This file was generated by the Julia OpenAPI Code Generator
# Do not modify this file directly. Modify the OpenAPI specification instead.
@doc raw"""BatchPersonalNameGeoSubclassificationOut
Represents the output of inferring the LIKELY country subclassification (regional names).
BatchPersonalNameGeoSubclassificationOut(;
personalNames=nothing,
)
- personalNames::Vector{PersonalNameGeoSubclassificationOut} : Classified names at sub country level (region or state)
"""
Base.@kwdef mutable struct BatchPersonalNameGeoSubclassificationOut <: OpenAPI.APIModel
personalNames::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{PersonalNameGeoSubclassificationOut} }
function BatchPersonalNameGeoSubclassificationOut(personalNames, )
OpenAPI.validate_property(BatchPersonalNameGeoSubclassificationOut, Symbol("personalNames"), personalNames)
return new(personalNames, )
end
end # type BatchPersonalNameGeoSubclassificationOut
const _property_types_BatchPersonalNameGeoSubclassificationOut = Dict{Symbol,String}(Symbol("personalNames")=>"Vector{PersonalNameGeoSubclassificationOut}", )
OpenAPI.property_type(::Type{ BatchPersonalNameGeoSubclassificationOut }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_BatchPersonalNameGeoSubclassificationOut[name]))}
function check_required(o::BatchPersonalNameGeoSubclassificationOut)
true
end
function OpenAPI.validate_property(::Type{ BatchPersonalNameGeoSubclassificationOut }, name::Symbol, val)
end
| NamSor | https://github.com/NeroBlackstone/NamSor.jl.git |
|
[
"MIT"
] | 0.1.0 | 2d6ab091a1f4af72f40a76fe35b2c01982aa0bbf | code | 1295 | # This file was generated by the Julia OpenAPI Code Generator
# Do not modify this file directly. Modify the OpenAPI specification instead.
@doc raw"""BatchPersonalNameGeoSubdivisionIn
BatchPersonalNameGeoSubdivisionIn(;
personalNames=nothing,
)
- personalNames::Vector{PersonalNameGeoSubdivisionIn}
"""
Base.@kwdef mutable struct BatchPersonalNameGeoSubdivisionIn <: OpenAPI.APIModel
personalNames::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{PersonalNameGeoSubdivisionIn} }
function BatchPersonalNameGeoSubdivisionIn(personalNames, )
OpenAPI.validate_property(BatchPersonalNameGeoSubdivisionIn, Symbol("personalNames"), personalNames)
return new(personalNames, )
end
end # type BatchPersonalNameGeoSubdivisionIn
const _property_types_BatchPersonalNameGeoSubdivisionIn = Dict{Symbol,String}(Symbol("personalNames")=>"Vector{PersonalNameGeoSubdivisionIn}", )
OpenAPI.property_type(::Type{ BatchPersonalNameGeoSubdivisionIn }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_BatchPersonalNameGeoSubdivisionIn[name]))}
function check_required(o::BatchPersonalNameGeoSubdivisionIn)
true
end
function OpenAPI.validate_property(::Type{ BatchPersonalNameGeoSubdivisionIn }, name::Symbol, val)
end
| NamSor | https://github.com/NeroBlackstone/NamSor.jl.git |
|
[
"MIT"
] | 0.1.0 | 2d6ab091a1f4af72f40a76fe35b2c01982aa0bbf | code | 1099 | # This file was generated by the Julia OpenAPI Code Generator
# Do not modify this file directly. Modify the OpenAPI specification instead.
@doc raw"""BatchPersonalNameIn
BatchPersonalNameIn(;
personalNames=nothing,
)
- personalNames::Vector{PersonalNameIn}
"""
Base.@kwdef mutable struct BatchPersonalNameIn <: OpenAPI.APIModel
personalNames::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{PersonalNameIn} }
function BatchPersonalNameIn(personalNames, )
OpenAPI.validate_property(BatchPersonalNameIn, Symbol("personalNames"), personalNames)
return new(personalNames, )
end
end # type BatchPersonalNameIn
const _property_types_BatchPersonalNameIn = Dict{Symbol,String}(Symbol("personalNames")=>"Vector{PersonalNameIn}", )
OpenAPI.property_type(::Type{ BatchPersonalNameIn }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_BatchPersonalNameIn[name]))}
function check_required(o::BatchPersonalNameIn)
true
end
function OpenAPI.validate_property(::Type{ BatchPersonalNameIn }, name::Symbol, val)
end
| NamSor | https://github.com/NeroBlackstone/NamSor.jl.git |
|
[
"MIT"
] | 0.1.0 | 2d6ab091a1f4af72f40a76fe35b2c01982aa0bbf | code | 1337 | # This file was generated by the Julia OpenAPI Code Generator
# Do not modify this file directly. Modify the OpenAPI specification instead.
@doc raw"""BatchPersonalNameOriginedOut
Represents the output of inferring the LIKELY origin from a list of personal names.
BatchPersonalNameOriginedOut(;
personalNames=nothing,
)
- personalNames::Vector{PersonalNameOriginedOut} : Classified origined names
"""
Base.@kwdef mutable struct BatchPersonalNameOriginedOut <: OpenAPI.APIModel
personalNames::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{PersonalNameOriginedOut} }
function BatchPersonalNameOriginedOut(personalNames, )
OpenAPI.validate_property(BatchPersonalNameOriginedOut, Symbol("personalNames"), personalNames)
return new(personalNames, )
end
end # type BatchPersonalNameOriginedOut
const _property_types_BatchPersonalNameOriginedOut = Dict{Symbol,String}(Symbol("personalNames")=>"Vector{PersonalNameOriginedOut}", )
OpenAPI.property_type(::Type{ BatchPersonalNameOriginedOut }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_BatchPersonalNameOriginedOut[name]))}
function check_required(o::BatchPersonalNameOriginedOut)
true
end
function OpenAPI.validate_property(::Type{ BatchPersonalNameOriginedOut }, name::Symbol, val)
end
| NamSor | https://github.com/NeroBlackstone/NamSor.jl.git |
|
[
"MIT"
] | 0.1.0 | 2d6ab091a1f4af72f40a76fe35b2c01982aa0bbf | code | 1223 | # This file was generated by the Julia OpenAPI Code Generator
# Do not modify this file directly. Modify the OpenAPI specification instead.
@doc raw"""BatchPersonalNameParsedOut
BatchPersonalNameParsedOut(;
personalNames=nothing,
)
- personalNames::Vector{PersonalNameParsedOut} : Classified parsed names
"""
Base.@kwdef mutable struct BatchPersonalNameParsedOut <: OpenAPI.APIModel
personalNames::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{PersonalNameParsedOut} }
function BatchPersonalNameParsedOut(personalNames, )
OpenAPI.validate_property(BatchPersonalNameParsedOut, Symbol("personalNames"), personalNames)
return new(personalNames, )
end
end # type BatchPersonalNameParsedOut
const _property_types_BatchPersonalNameParsedOut = Dict{Symbol,String}(Symbol("personalNames")=>"Vector{PersonalNameParsedOut}", )
OpenAPI.property_type(::Type{ BatchPersonalNameParsedOut }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_BatchPersonalNameParsedOut[name]))}
function check_required(o::BatchPersonalNameParsedOut)
true
end
function OpenAPI.validate_property(::Type{ BatchPersonalNameParsedOut }, name::Symbol, val)
end
| NamSor | https://github.com/NeroBlackstone/NamSor.jl.git |
|
[
"MIT"
] | 0.1.0 | 2d6ab091a1f4af72f40a76fe35b2c01982aa0bbf | code | 1277 | # This file was generated by the Julia OpenAPI Code Generator
# Do not modify this file directly. Modify the OpenAPI specification instead.
@doc raw"""BatchPersonalNameReligionedOut
BatchPersonalNameReligionedOut(;
personalNames=nothing,
)
- personalNames::Vector{PersonalNameReligionedOut} : religious-coded names
"""
Base.@kwdef mutable struct BatchPersonalNameReligionedOut <: OpenAPI.APIModel
personalNames::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{PersonalNameReligionedOut} }
function BatchPersonalNameReligionedOut(personalNames, )
OpenAPI.validate_property(BatchPersonalNameReligionedOut, Symbol("personalNames"), personalNames)
return new(personalNames, )
end
end # type BatchPersonalNameReligionedOut
const _property_types_BatchPersonalNameReligionedOut = Dict{Symbol,String}(Symbol("personalNames")=>"Vector{PersonalNameReligionedOut}", )
OpenAPI.property_type(::Type{ BatchPersonalNameReligionedOut }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_BatchPersonalNameReligionedOut[name]))}
function check_required(o::BatchPersonalNameReligionedOut)
true
end
function OpenAPI.validate_property(::Type{ BatchPersonalNameReligionedOut }, name::Symbol, val)
end
| NamSor | https://github.com/NeroBlackstone/NamSor.jl.git |
|
[
"MIT"
] | 0.1.0 | 2d6ab091a1f4af72f40a76fe35b2c01982aa0bbf | code | 1253 | # This file was generated by the Julia OpenAPI Code Generator
# Do not modify this file directly. Modify the OpenAPI specification instead.
@doc raw"""BatchPersonalNameSubdivisionIn
BatchPersonalNameSubdivisionIn(;
personalNames=nothing,
)
- personalNames::Vector{PersonalNameSubdivisionIn}
"""
Base.@kwdef mutable struct BatchPersonalNameSubdivisionIn <: OpenAPI.APIModel
personalNames::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{PersonalNameSubdivisionIn} }
function BatchPersonalNameSubdivisionIn(personalNames, )
OpenAPI.validate_property(BatchPersonalNameSubdivisionIn, Symbol("personalNames"), personalNames)
return new(personalNames, )
end
end # type BatchPersonalNameSubdivisionIn
const _property_types_BatchPersonalNameSubdivisionIn = Dict{Symbol,String}(Symbol("personalNames")=>"Vector{PersonalNameSubdivisionIn}", )
OpenAPI.property_type(::Type{ BatchPersonalNameSubdivisionIn }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_BatchPersonalNameSubdivisionIn[name]))}
function check_required(o::BatchPersonalNameSubdivisionIn)
true
end
function OpenAPI.validate_property(::Type{ BatchPersonalNameSubdivisionIn }, name::Symbol, val)
end
| NamSor | https://github.com/NeroBlackstone/NamSor.jl.git |
|
[
"MIT"
] | 0.1.0 | 2d6ab091a1f4af72f40a76fe35b2c01982aa0bbf | code | 1446 | # This file was generated by the Julia OpenAPI Code Generator
# Do not modify this file directly. Modify the OpenAPI specification instead.
@doc raw"""BatchPersonalNameUSRaceEthnicityOut
Represents the output of inferring the LIKELY US race/ethnicity from a list of personal names.
BatchPersonalNameUSRaceEthnicityOut(;
personalNames=nothing,
)
- personalNames::Vector{PersonalNameUSRaceEthnicityOut} : Classified origined names
"""
Base.@kwdef mutable struct BatchPersonalNameUSRaceEthnicityOut <: OpenAPI.APIModel
personalNames::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{PersonalNameUSRaceEthnicityOut} }
function BatchPersonalNameUSRaceEthnicityOut(personalNames, )
OpenAPI.validate_property(BatchPersonalNameUSRaceEthnicityOut, Symbol("personalNames"), personalNames)
return new(personalNames, )
end
end # type BatchPersonalNameUSRaceEthnicityOut
const _property_types_BatchPersonalNameUSRaceEthnicityOut = Dict{Symbol,String}(Symbol("personalNames")=>"Vector{PersonalNameUSRaceEthnicityOut}", )
OpenAPI.property_type(::Type{ BatchPersonalNameUSRaceEthnicityOut }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_BatchPersonalNameUSRaceEthnicityOut[name]))}
function check_required(o::BatchPersonalNameUSRaceEthnicityOut)
true
end
function OpenAPI.validate_property(::Type{ BatchPersonalNameUSRaceEthnicityOut }, name::Symbol, val)
end
| NamSor | https://github.com/NeroBlackstone/NamSor.jl.git |
|
[
"MIT"
] | 0.1.0 | 2d6ab091a1f4af72f40a76fe35b2c01982aa0bbf | code | 1371 | # This file was generated by the Julia OpenAPI Code Generator
# Do not modify this file directly. Modify the OpenAPI specification instead.
@doc raw"""BatchProperNounCategorizedOut
Represents the output of inferring the common type (anthroponym, toponym, brand, etc.) from a list of proper names.
BatchProperNounCategorizedOut(;
properNouns=nothing,
)
- properNouns::Vector{ProperNounCategorizedOut} : Classified typed proper names
"""
Base.@kwdef mutable struct BatchProperNounCategorizedOut <: OpenAPI.APIModel
properNouns::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{ProperNounCategorizedOut} }
function BatchProperNounCategorizedOut(properNouns, )
OpenAPI.validate_property(BatchProperNounCategorizedOut, Symbol("properNouns"), properNouns)
return new(properNouns, )
end
end # type BatchProperNounCategorizedOut
const _property_types_BatchProperNounCategorizedOut = Dict{Symbol,String}(Symbol("properNouns")=>"Vector{ProperNounCategorizedOut}", )
OpenAPI.property_type(::Type{ BatchProperNounCategorizedOut }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_BatchProperNounCategorizedOut[name]))}
function check_required(o::BatchProperNounCategorizedOut)
true
end
function OpenAPI.validate_property(::Type{ BatchProperNounCategorizedOut }, name::Symbol, val)
end
| NamSor | https://github.com/NeroBlackstone/NamSor.jl.git |
|
[
"MIT"
] | 0.1.0 | 2d6ab091a1f4af72f40a76fe35b2c01982aa0bbf | code | 2277 | # This file was generated by the Julia OpenAPI Code Generator
# Do not modify this file directly. Modify the OpenAPI specification instead.
@doc raw"""CommunityEngageOptionOut
CommunityEngageOptionOut(;
genderFilter=nothing,
ethnicityFilter=nothing,
countryOutFilter=nothing,
usRaceEthnicityFilter=nothing,
)
- genderFilter::Vector{String} : The gender filter (null to allow all)
- ethnicityFilter::Vector{String} : The ethnicity filter (null to allow all)
- countryOutFilter::Vector{String} : The output country filter (null to allow all)
- usRaceEthnicityFilter::Vector{String} : The output US race/ethnicity filter (null to allow all)
"""
Base.@kwdef mutable struct CommunityEngageOptionOut <: OpenAPI.APIModel
genderFilter::Union{Nothing, Vector{String}} = nothing
ethnicityFilter::Union{Nothing, Vector{String}} = nothing
countryOutFilter::Union{Nothing, Vector{String}} = nothing
usRaceEthnicityFilter::Union{Nothing, Vector{String}} = nothing
function CommunityEngageOptionOut(genderFilter, ethnicityFilter, countryOutFilter, usRaceEthnicityFilter, )
OpenAPI.validate_property(CommunityEngageOptionOut, Symbol("genderFilter"), genderFilter)
OpenAPI.validate_property(CommunityEngageOptionOut, Symbol("ethnicityFilter"), ethnicityFilter)
OpenAPI.validate_property(CommunityEngageOptionOut, Symbol("countryOutFilter"), countryOutFilter)
OpenAPI.validate_property(CommunityEngageOptionOut, Symbol("usRaceEthnicityFilter"), usRaceEthnicityFilter)
return new(genderFilter, ethnicityFilter, countryOutFilter, usRaceEthnicityFilter, )
end
end # type CommunityEngageOptionOut
const _property_types_CommunityEngageOptionOut = Dict{Symbol,String}(Symbol("genderFilter")=>"Vector{String}", Symbol("ethnicityFilter")=>"Vector{String}", Symbol("countryOutFilter")=>"Vector{String}", Symbol("usRaceEthnicityFilter")=>"Vector{String}", )
OpenAPI.property_type(::Type{ CommunityEngageOptionOut }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_CommunityEngageOptionOut[name]))}
function check_required(o::CommunityEngageOptionOut)
true
end
function OpenAPI.validate_property(::Type{ CommunityEngageOptionOut }, name::Symbol, val)
end
| NamSor | https://github.com/NeroBlackstone/NamSor.jl.git |
|
[
"MIT"
] | 0.1.0 | 2d6ab091a1f4af72f40a76fe35b2c01982aa0bbf | code | 3527 | # This file was generated by the Julia OpenAPI Code Generator
# Do not modify this file directly. Modify the OpenAPI specification instead.
@doc raw"""CommunityEngageOut
Represent multiple classifications for community engagement (gender, country, origin, diaspora)
CommunityEngageOut(;
id=nothing,
PersonalNameDiasporaedOut=nothing,
PersonalNameOriginedOut=nothing,
country=nothing,
gender=nothing,
PersonalNameUSRaceEthnicityOut=nothing,
prime=nothing,
scoped=nothing,
script=nothing,
)
- id::String
- PersonalNameDiasporaedOut::PersonalNameDiasporaedOut
- PersonalNameOriginedOut::PersonalNameOriginedOut
- country::PersonalNameGeoOut
- gender::PersonalNameGenderedOut
- PersonalNameUSRaceEthnicityOut::PersonalNameUSRaceEthnicityOut
- prime::Bool
- scoped::Bool
- script::String
"""
Base.@kwdef mutable struct CommunityEngageOut <: OpenAPI.APIModel
id::Union{Nothing, String} = nothing
PersonalNameDiasporaedOut = nothing # spec type: Union{ Nothing, PersonalNameDiasporaedOut }
PersonalNameOriginedOut = nothing # spec type: Union{ Nothing, PersonalNameOriginedOut }
country = nothing # spec type: Union{ Nothing, PersonalNameGeoOut }
gender = nothing # spec type: Union{ Nothing, PersonalNameGenderedOut }
PersonalNameUSRaceEthnicityOut = nothing # spec type: Union{ Nothing, PersonalNameUSRaceEthnicityOut }
prime::Union{Nothing, Bool} = nothing
scoped::Union{Nothing, Bool} = nothing
script::Union{Nothing, String} = nothing
function CommunityEngageOut(id, PersonalNameDiasporaedOut, PersonalNameOriginedOut, country, gender, PersonalNameUSRaceEthnicityOut, prime, scoped, script, )
OpenAPI.validate_property(CommunityEngageOut, Symbol("id"), id)
OpenAPI.validate_property(CommunityEngageOut, Symbol("PersonalNameDiasporaedOut"), PersonalNameDiasporaedOut)
OpenAPI.validate_property(CommunityEngageOut, Symbol("PersonalNameOriginedOut"), PersonalNameOriginedOut)
OpenAPI.validate_property(CommunityEngageOut, Symbol("country"), country)
OpenAPI.validate_property(CommunityEngageOut, Symbol("gender"), gender)
OpenAPI.validate_property(CommunityEngageOut, Symbol("PersonalNameUSRaceEthnicityOut"), PersonalNameUSRaceEthnicityOut)
OpenAPI.validate_property(CommunityEngageOut, Symbol("prime"), prime)
OpenAPI.validate_property(CommunityEngageOut, Symbol("scoped"), scoped)
OpenAPI.validate_property(CommunityEngageOut, Symbol("script"), script)
return new(id, PersonalNameDiasporaedOut, PersonalNameOriginedOut, country, gender, PersonalNameUSRaceEthnicityOut, prime, scoped, script, )
end
end # type CommunityEngageOut
const _property_types_CommunityEngageOut = Dict{Symbol,String}(Symbol("id")=>"String", Symbol("PersonalNameDiasporaedOut")=>"PersonalNameDiasporaedOut", Symbol("PersonalNameOriginedOut")=>"PersonalNameOriginedOut", Symbol("country")=>"PersonalNameGeoOut", Symbol("gender")=>"PersonalNameGenderedOut", Symbol("PersonalNameUSRaceEthnicityOut")=>"PersonalNameUSRaceEthnicityOut", Symbol("prime")=>"Bool", Symbol("scoped")=>"Bool", Symbol("script")=>"String", )
OpenAPI.property_type(::Type{ CommunityEngageOut }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_CommunityEngageOut[name]))}
function check_required(o::CommunityEngageOut)
true
end
function OpenAPI.validate_property(::Type{ CommunityEngageOut }, name::Symbol, val)
end
| NamSor | https://github.com/NeroBlackstone/NamSor.jl.git |
|
[
"MIT"
] | 0.1.0 | 2d6ab091a1f4af72f40a76fe35b2c01982aa0bbf | code | 1672 | # This file was generated by the Julia OpenAPI Code Generator
# Do not modify this file directly. Modify the OpenAPI specification instead.
@doc raw"""CorridorIn
Represent any transnational interaction between names (ex. remittance, communication, cross-border investment, airline travel
CorridorIn(;
id=nothing,
firstLastNameGeoFrom=nothing,
firstLastNameGeoTo=nothing,
)
- id::String
- firstLastNameGeoFrom::FirstLastNameGeoIn
- firstLastNameGeoTo::FirstLastNameGeoIn
"""
Base.@kwdef mutable struct CorridorIn <: OpenAPI.APIModel
id::Union{Nothing, String} = nothing
firstLastNameGeoFrom = nothing # spec type: Union{ Nothing, FirstLastNameGeoIn }
firstLastNameGeoTo = nothing # spec type: Union{ Nothing, FirstLastNameGeoIn }
function CorridorIn(id, firstLastNameGeoFrom, firstLastNameGeoTo, )
OpenAPI.validate_property(CorridorIn, Symbol("id"), id)
OpenAPI.validate_property(CorridorIn, Symbol("firstLastNameGeoFrom"), firstLastNameGeoFrom)
OpenAPI.validate_property(CorridorIn, Symbol("firstLastNameGeoTo"), firstLastNameGeoTo)
return new(id, firstLastNameGeoFrom, firstLastNameGeoTo, )
end
end # type CorridorIn
const _property_types_CorridorIn = Dict{Symbol,String}(Symbol("id")=>"String", Symbol("firstLastNameGeoFrom")=>"FirstLastNameGeoIn", Symbol("firstLastNameGeoTo")=>"FirstLastNameGeoIn", )
OpenAPI.property_type(::Type{ CorridorIn }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_CorridorIn[name]))}
function check_required(o::CorridorIn)
true
end
function OpenAPI.validate_property(::Type{ CorridorIn }, name::Symbol, val)
end
| NamSor | https://github.com/NeroBlackstone/NamSor.jl.git |
|
[
"MIT"
] | 0.1.0 | 2d6ab091a1f4af72f40a76fe35b2c01982aa0bbf | code | 2427 | # This file was generated by the Julia OpenAPI Code Generator
# Do not modify this file directly. Modify the OpenAPI specification instead.
@doc raw"""CorridorOut
Represent multiple classifications for corridor sender and receiver (gender, country, origin, diaspora)
CorridorOut(;
id=nothing,
FirstLastNameGenderedOut=nothing,
FirstLastNameOriginedOut=nothing,
FirstLastNameDiasporaedOut=nothing,
script=nothing,
)
- id::String
- FirstLastNameGenderedOut::FirstLastNameGenderedOut
- FirstLastNameOriginedOut::FirstLastNameOriginedOut
- FirstLastNameDiasporaedOut::FirstLastNameDiasporaedOut
- script::String
"""
Base.@kwdef mutable struct CorridorOut <: OpenAPI.APIModel
id::Union{Nothing, String} = nothing
FirstLastNameGenderedOut = nothing # spec type: Union{ Nothing, FirstLastNameGenderedOut }
FirstLastNameOriginedOut = nothing # spec type: Union{ Nothing, FirstLastNameOriginedOut }
FirstLastNameDiasporaedOut = nothing # spec type: Union{ Nothing, FirstLastNameDiasporaedOut }
script::Union{Nothing, String} = nothing
function CorridorOut(id, FirstLastNameGenderedOut, FirstLastNameOriginedOut, FirstLastNameDiasporaedOut, script, )
OpenAPI.validate_property(CorridorOut, Symbol("id"), id)
OpenAPI.validate_property(CorridorOut, Symbol("FirstLastNameGenderedOut"), FirstLastNameGenderedOut)
OpenAPI.validate_property(CorridorOut, Symbol("FirstLastNameOriginedOut"), FirstLastNameOriginedOut)
OpenAPI.validate_property(CorridorOut, Symbol("FirstLastNameDiasporaedOut"), FirstLastNameDiasporaedOut)
OpenAPI.validate_property(CorridorOut, Symbol("script"), script)
return new(id, FirstLastNameGenderedOut, FirstLastNameOriginedOut, FirstLastNameDiasporaedOut, script, )
end
end # type CorridorOut
const _property_types_CorridorOut = Dict{Symbol,String}(Symbol("id")=>"String", Symbol("FirstLastNameGenderedOut")=>"FirstLastNameGenderedOut", Symbol("FirstLastNameOriginedOut")=>"FirstLastNameOriginedOut", Symbol("FirstLastNameDiasporaedOut")=>"FirstLastNameDiasporaedOut", Symbol("script")=>"String", )
OpenAPI.property_type(::Type{ CorridorOut }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_CorridorOut[name]))}
function check_required(o::CorridorOut)
true
end
function OpenAPI.validate_property(::Type{ CorridorOut }, name::Symbol, val)
end
| NamSor | https://github.com/NeroBlackstone/NamSor.jl.git |
|
[
"MIT"
] | 0.1.0 | 2d6ab091a1f4af72f40a76fe35b2c01982aa0bbf | code | 1187 | # This file was generated by the Julia OpenAPI Code Generator
# Do not modify this file directly. Modify the OpenAPI specification instead.
@doc raw"""FeedbackLoopOut
FeedbackLoopOut(;
feedbackCredits=nothing,
)
- feedbackCredits::Int64 : Number of units recredited as per feedback loop successful classification
"""
Base.@kwdef mutable struct FeedbackLoopOut <: OpenAPI.APIModel
feedbackCredits::Union{Nothing, Int64} = nothing
function FeedbackLoopOut(feedbackCredits, )
OpenAPI.validate_property(FeedbackLoopOut, Symbol("feedbackCredits"), feedbackCredits)
return new(feedbackCredits, )
end
end # type FeedbackLoopOut
const _property_types_FeedbackLoopOut = Dict{Symbol,String}(Symbol("feedbackCredits")=>"Int64", )
OpenAPI.property_type(::Type{ FeedbackLoopOut }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_FeedbackLoopOut[name]))}
function check_required(o::FeedbackLoopOut)
true
end
function OpenAPI.validate_property(::Type{ FeedbackLoopOut }, name::Symbol, val)
if name === Symbol("feedbackCredits")
OpenAPI.validate_param(name, "FeedbackLoopOut", :format, val, "int64")
end
end
| NamSor | https://github.com/NeroBlackstone/NamSor.jl.git |
|
[
"MIT"
] | 0.1.0 | 2d6ab091a1f4af72f40a76fe35b2c01982aa0bbf | code | 5223 | # This file was generated by the Julia OpenAPI Code Generator
# Do not modify this file directly. Modify the OpenAPI specification instead.
@doc raw"""FirstLastNameCasteOut
Represents the output of inferring the LIKELY caste from a personal Hindu/Indian name.
FirstLastNameCasteOut(;
script=nothing,
id=nothing,
explanation=nothing,
firstName=nothing,
lastName=nothing,
caste=nothing,
casteAlt=nothing,
casteTop=nothing,
score=nothing,
probabilityCalibrated=nothing,
probabilityAltCalibrated=nothing,
)
- script::String
- id::String
- explanation::String
- firstName::String : The first name (also known as given name)
- lastName::String : The last name (also known as family name, or surname)
- caste::String : Most likely caste
- casteAlt::String : Second best alternative : caste
- casteTop::Vector{String} : List caste(top 10)
- score::Float64 : Compatibility to NamSor_v1 Origin score value. Higher score is better, but score is not normalized. Use calibratedProbability if available.
- probabilityCalibrated::Float64 : The calibrated probability for caste to have been guessed correctly. -1 = still calibrating.
- probabilityAltCalibrated::Float64 : The calibrated probability for caste OR casteAlt to have been guessed correctly. -1 = still calibrating.
"""
Base.@kwdef mutable struct FirstLastNameCasteOut <: OpenAPI.APIModel
script::Union{Nothing, String} = nothing
id::Union{Nothing, String} = nothing
explanation::Union{Nothing, String} = nothing
firstName::Union{Nothing, String} = nothing
lastName::Union{Nothing, String} = nothing
caste::Union{Nothing, String} = nothing
casteAlt::Union{Nothing, String} = nothing
casteTop::Union{Nothing, Vector{String}} = nothing
score::Union{Nothing, Float64} = nothing
probabilityCalibrated::Union{Nothing, Float64} = nothing
probabilityAltCalibrated::Union{Nothing, Float64} = nothing
function FirstLastNameCasteOut(script, id, explanation, firstName, lastName, caste, casteAlt, casteTop, score, probabilityCalibrated, probabilityAltCalibrated, )
OpenAPI.validate_property(FirstLastNameCasteOut, Symbol("script"), script)
OpenAPI.validate_property(FirstLastNameCasteOut, Symbol("id"), id)
OpenAPI.validate_property(FirstLastNameCasteOut, Symbol("explanation"), explanation)
OpenAPI.validate_property(FirstLastNameCasteOut, Symbol("firstName"), firstName)
OpenAPI.validate_property(FirstLastNameCasteOut, Symbol("lastName"), lastName)
OpenAPI.validate_property(FirstLastNameCasteOut, Symbol("caste"), caste)
OpenAPI.validate_property(FirstLastNameCasteOut, Symbol("casteAlt"), casteAlt)
OpenAPI.validate_property(FirstLastNameCasteOut, Symbol("casteTop"), casteTop)
OpenAPI.validate_property(FirstLastNameCasteOut, Symbol("score"), score)
OpenAPI.validate_property(FirstLastNameCasteOut, Symbol("probabilityCalibrated"), probabilityCalibrated)
OpenAPI.validate_property(FirstLastNameCasteOut, Symbol("probabilityAltCalibrated"), probabilityAltCalibrated)
return new(script, id, explanation, firstName, lastName, caste, casteAlt, casteTop, score, probabilityCalibrated, probabilityAltCalibrated, )
end
end # type FirstLastNameCasteOut
const _property_types_FirstLastNameCasteOut = Dict{Symbol,String}(Symbol("script")=>"String", Symbol("id")=>"String", Symbol("explanation")=>"String", Symbol("firstName")=>"String", Symbol("lastName")=>"String", Symbol("caste")=>"String", Symbol("casteAlt")=>"String", Symbol("casteTop")=>"Vector{String}", Symbol("score")=>"Float64", Symbol("probabilityCalibrated")=>"Float64", Symbol("probabilityAltCalibrated")=>"Float64", )
OpenAPI.property_type(::Type{ FirstLastNameCasteOut }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_FirstLastNameCasteOut[name]))}
function check_required(o::FirstLastNameCasteOut)
true
end
function OpenAPI.validate_property(::Type{ FirstLastNameCasteOut }, name::Symbol, val)
if name === Symbol("score")
OpenAPI.validate_param(name, "FirstLastNameCasteOut", :format, val, "double")
end
if name === Symbol("score")
OpenAPI.validate_param(name, "FirstLastNameCasteOut", :maximum, val, 100, false)
OpenAPI.validate_param(name, "FirstLastNameCasteOut", :minimum, val, 0, false)
end
if name === Symbol("probabilityCalibrated")
OpenAPI.validate_param(name, "FirstLastNameCasteOut", :format, val, "double")
end
if name === Symbol("probabilityCalibrated")
OpenAPI.validate_param(name, "FirstLastNameCasteOut", :maximum, val, 1, false)
OpenAPI.validate_param(name, "FirstLastNameCasteOut", :minimum, val, -1, false)
end
if name === Symbol("probabilityAltCalibrated")
OpenAPI.validate_param(name, "FirstLastNameCasteOut", :format, val, "double")
end
if name === Symbol("probabilityAltCalibrated")
OpenAPI.validate_param(name, "FirstLastNameCasteOut", :maximum, val, 1, false)
OpenAPI.validate_param(name, "FirstLastNameCasteOut", :minimum, val, -1, false)
end
end
| NamSor | https://github.com/NeroBlackstone/NamSor.jl.git |
|
[
"MIT"
] | 0.1.0 | 2d6ab091a1f4af72f40a76fe35b2c01982aa0bbf | code | 5519 | # This file was generated by the Julia OpenAPI Code Generator
# Do not modify this file directly. Modify the OpenAPI specification instead.
@doc raw"""FirstLastNameCastegroupOut
Represents the output of inferring the LIKELY caste group from a personal Hindu/Indian name.
FirstLastNameCastegroupOut(;
script=nothing,
id=nothing,
explanation=nothing,
firstName=nothing,
lastName=nothing,
castegroup=nothing,
castegroupAlt=nothing,
castegroupTop=nothing,
score=nothing,
probabilityCalibrated=nothing,
probabilityAltCalibrated=nothing,
)
- script::String
- id::String
- explanation::String
- firstName::String : The first name (also known as given name)
- lastName::String : The last name (also known as family name, or surname)
- castegroup::String : Most likely caste group
- castegroupAlt::String : Second best alternative : caste group
- castegroupTop::Vector{String} : List caste group (top 10)
- score::Float64 : Compatibility to NamSor_v1 Origin score value. Higher score is better, but score is not normalized. Use calibratedProbability if available.
- probabilityCalibrated::Float64 : The calibrated probability for caste to have been guessed correctly. -1 = still calibrating.
- probabilityAltCalibrated::Float64 : The calibrated probability for caste OR casteAlt to have been guessed correctly. -1 = still calibrating.
"""
Base.@kwdef mutable struct FirstLastNameCastegroupOut <: OpenAPI.APIModel
script::Union{Nothing, String} = nothing
id::Union{Nothing, String} = nothing
explanation::Union{Nothing, String} = nothing
firstName::Union{Nothing, String} = nothing
lastName::Union{Nothing, String} = nothing
castegroup::Union{Nothing, String} = nothing
castegroupAlt::Union{Nothing, String} = nothing
castegroupTop::Union{Nothing, Vector{String}} = nothing
score::Union{Nothing, Float64} = nothing
probabilityCalibrated::Union{Nothing, Float64} = nothing
probabilityAltCalibrated::Union{Nothing, Float64} = nothing
function FirstLastNameCastegroupOut(script, id, explanation, firstName, lastName, castegroup, castegroupAlt, castegroupTop, score, probabilityCalibrated, probabilityAltCalibrated, )
OpenAPI.validate_property(FirstLastNameCastegroupOut, Symbol("script"), script)
OpenAPI.validate_property(FirstLastNameCastegroupOut, Symbol("id"), id)
OpenAPI.validate_property(FirstLastNameCastegroupOut, Symbol("explanation"), explanation)
OpenAPI.validate_property(FirstLastNameCastegroupOut, Symbol("firstName"), firstName)
OpenAPI.validate_property(FirstLastNameCastegroupOut, Symbol("lastName"), lastName)
OpenAPI.validate_property(FirstLastNameCastegroupOut, Symbol("castegroup"), castegroup)
OpenAPI.validate_property(FirstLastNameCastegroupOut, Symbol("castegroupAlt"), castegroupAlt)
OpenAPI.validate_property(FirstLastNameCastegroupOut, Symbol("castegroupTop"), castegroupTop)
OpenAPI.validate_property(FirstLastNameCastegroupOut, Symbol("score"), score)
OpenAPI.validate_property(FirstLastNameCastegroupOut, Symbol("probabilityCalibrated"), probabilityCalibrated)
OpenAPI.validate_property(FirstLastNameCastegroupOut, Symbol("probabilityAltCalibrated"), probabilityAltCalibrated)
return new(script, id, explanation, firstName, lastName, castegroup, castegroupAlt, castegroupTop, score, probabilityCalibrated, probabilityAltCalibrated, )
end
end # type FirstLastNameCastegroupOut
const _property_types_FirstLastNameCastegroupOut = Dict{Symbol,String}(Symbol("script")=>"String", Symbol("id")=>"String", Symbol("explanation")=>"String", Symbol("firstName")=>"String", Symbol("lastName")=>"String", Symbol("castegroup")=>"String", Symbol("castegroupAlt")=>"String", Symbol("castegroupTop")=>"Vector{String}", Symbol("score")=>"Float64", Symbol("probabilityCalibrated")=>"Float64", Symbol("probabilityAltCalibrated")=>"Float64", )
OpenAPI.property_type(::Type{ FirstLastNameCastegroupOut }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_FirstLastNameCastegroupOut[name]))}
function check_required(o::FirstLastNameCastegroupOut)
true
end
function OpenAPI.validate_property(::Type{ FirstLastNameCastegroupOut }, name::Symbol, val)
if name === Symbol("score")
OpenAPI.validate_param(name, "FirstLastNameCastegroupOut", :format, val, "double")
end
if name === Symbol("score")
OpenAPI.validate_param(name, "FirstLastNameCastegroupOut", :maximum, val, 100, false)
OpenAPI.validate_param(name, "FirstLastNameCastegroupOut", :minimum, val, 0, false)
end
if name === Symbol("probabilityCalibrated")
OpenAPI.validate_param(name, "FirstLastNameCastegroupOut", :format, val, "double")
end
if name === Symbol("probabilityCalibrated")
OpenAPI.validate_param(name, "FirstLastNameCastegroupOut", :maximum, val, 1, false)
OpenAPI.validate_param(name, "FirstLastNameCastegroupOut", :minimum, val, -1, false)
end
if name === Symbol("probabilityAltCalibrated")
OpenAPI.validate_param(name, "FirstLastNameCastegroupOut", :format, val, "double")
end
if name === Symbol("probabilityAltCalibrated")
OpenAPI.validate_param(name, "FirstLastNameCastegroupOut", :maximum, val, 1, false)
OpenAPI.validate_param(name, "FirstLastNameCastegroupOut", :minimum, val, -1, false)
end
end
| NamSor | https://github.com/NeroBlackstone/NamSor.jl.git |
|
[
"MIT"
] | 0.1.0 | 2d6ab091a1f4af72f40a76fe35b2c01982aa0bbf | code | 7227 | # This file was generated by the Julia OpenAPI Code Generator
# Do not modify this file directly. Modify the OpenAPI specification instead.
@doc raw"""FirstLastNameDiasporaedOut
Represents the output of inferring the LIKELY ethnicity from a personal name, given an country of residence.
FirstLastNameDiasporaedOut(;
script=nothing,
id=nothing,
explanation=nothing,
firstName=nothing,
lastName=nothing,
score=nothing,
ethnicityAlt=nothing,
ethnicity=nothing,
lifted=nothing,
countryIso2=nothing,
ethnicitiesTop=nothing,
probabilityCalibrated=nothing,
probabilityAltCalibrated=nothing,
religionStats=nothing,
religionStatsAlt=nothing,
)
- script::String
- id::String
- explanation::String
- firstName::String : The first name (also known as given name)
- lastName::String : The last name (also known as family name, or surname)
- score::Float64 : Compatibility to NamSor_v1 Diaspora score value. Higher score is better, but score is not normalized. Use calibratedProbability if available.
- ethnicityAlt::String : The second best alternative ethnicity
- ethnicity::String : The most likely ethnicity
- lifted::Bool : Indicates if the output ethnicity is based on machine learning only, or further lifted as a known fact by a country-specific rule. Let us know if you believe ethnicity is incorrect on a specific case where lifted is true.
- countryIso2::String : From input data, the countryIso2 of geographic context (US,CA etc.)
- ethnicitiesTop::Vector{String} : List most likely ethnicities (top 10)
- probabilityCalibrated::Float64 : The calibrated probability for ethnicity to have been guessed correctly. -1 = still calibrating.
- probabilityAltCalibrated::Float64 : The calibrated probability for ethnicity OR ethnicityAlt to have been guessed correctly. -1 = still calibrating.
- religionStats::Vector{ReligionStatOut} : Geographic religious statistics, assuming ethnicity is correctly predicted.
- religionStatsAlt::Vector{ReligionStatOut} : Geographic religious statistics, for country best alternative.
"""
Base.@kwdef mutable struct FirstLastNameDiasporaedOut <: OpenAPI.APIModel
script::Union{Nothing, String} = nothing
id::Union{Nothing, String} = nothing
explanation::Union{Nothing, String} = nothing
firstName::Union{Nothing, String} = nothing
lastName::Union{Nothing, String} = nothing
score::Union{Nothing, Float64} = nothing
ethnicityAlt::Union{Nothing, String} = nothing
ethnicity::Union{Nothing, String} = nothing
lifted::Union{Nothing, Bool} = nothing
countryIso2::Union{Nothing, String} = nothing
ethnicitiesTop::Union{Nothing, Vector{String}} = nothing
probabilityCalibrated::Union{Nothing, Float64} = nothing
probabilityAltCalibrated::Union{Nothing, Float64} = nothing
religionStats::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{ReligionStatOut} }
religionStatsAlt::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{ReligionStatOut} }
function FirstLastNameDiasporaedOut(script, id, explanation, firstName, lastName, score, ethnicityAlt, ethnicity, lifted, countryIso2, ethnicitiesTop, probabilityCalibrated, probabilityAltCalibrated, religionStats, religionStatsAlt, )
OpenAPI.validate_property(FirstLastNameDiasporaedOut, Symbol("script"), script)
OpenAPI.validate_property(FirstLastNameDiasporaedOut, Symbol("id"), id)
OpenAPI.validate_property(FirstLastNameDiasporaedOut, Symbol("explanation"), explanation)
OpenAPI.validate_property(FirstLastNameDiasporaedOut, Symbol("firstName"), firstName)
OpenAPI.validate_property(FirstLastNameDiasporaedOut, Symbol("lastName"), lastName)
OpenAPI.validate_property(FirstLastNameDiasporaedOut, Symbol("score"), score)
OpenAPI.validate_property(FirstLastNameDiasporaedOut, Symbol("ethnicityAlt"), ethnicityAlt)
OpenAPI.validate_property(FirstLastNameDiasporaedOut, Symbol("ethnicity"), ethnicity)
OpenAPI.validate_property(FirstLastNameDiasporaedOut, Symbol("lifted"), lifted)
OpenAPI.validate_property(FirstLastNameDiasporaedOut, Symbol("countryIso2"), countryIso2)
OpenAPI.validate_property(FirstLastNameDiasporaedOut, Symbol("ethnicitiesTop"), ethnicitiesTop)
OpenAPI.validate_property(FirstLastNameDiasporaedOut, Symbol("probabilityCalibrated"), probabilityCalibrated)
OpenAPI.validate_property(FirstLastNameDiasporaedOut, Symbol("probabilityAltCalibrated"), probabilityAltCalibrated)
OpenAPI.validate_property(FirstLastNameDiasporaedOut, Symbol("religionStats"), religionStats)
OpenAPI.validate_property(FirstLastNameDiasporaedOut, Symbol("religionStatsAlt"), religionStatsAlt)
return new(script, id, explanation, firstName, lastName, score, ethnicityAlt, ethnicity, lifted, countryIso2, ethnicitiesTop, probabilityCalibrated, probabilityAltCalibrated, religionStats, religionStatsAlt, )
end
end # type FirstLastNameDiasporaedOut
const _property_types_FirstLastNameDiasporaedOut = Dict{Symbol,String}(Symbol("script")=>"String", Symbol("id")=>"String", Symbol("explanation")=>"String", Symbol("firstName")=>"String", Symbol("lastName")=>"String", Symbol("score")=>"Float64", Symbol("ethnicityAlt")=>"String", Symbol("ethnicity")=>"String", Symbol("lifted")=>"Bool", Symbol("countryIso2")=>"String", Symbol("ethnicitiesTop")=>"Vector{String}", Symbol("probabilityCalibrated")=>"Float64", Symbol("probabilityAltCalibrated")=>"Float64", Symbol("religionStats")=>"Vector{ReligionStatOut}", Symbol("religionStatsAlt")=>"Vector{ReligionStatOut}", )
OpenAPI.property_type(::Type{ FirstLastNameDiasporaedOut }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_FirstLastNameDiasporaedOut[name]))}
function check_required(o::FirstLastNameDiasporaedOut)
true
end
function OpenAPI.validate_property(::Type{ FirstLastNameDiasporaedOut }, name::Symbol, val)
if name === Symbol("score")
OpenAPI.validate_param(name, "FirstLastNameDiasporaedOut", :format, val, "double")
end
if name === Symbol("score")
OpenAPI.validate_param(name, "FirstLastNameDiasporaedOut", :maximum, val, 100, false)
OpenAPI.validate_param(name, "FirstLastNameDiasporaedOut", :minimum, val, 0, false)
end
if name === Symbol("probabilityCalibrated")
OpenAPI.validate_param(name, "FirstLastNameDiasporaedOut", :format, val, "double")
end
if name === Symbol("probabilityCalibrated")
OpenAPI.validate_param(name, "FirstLastNameDiasporaedOut", :maximum, val, 1, false)
OpenAPI.validate_param(name, "FirstLastNameDiasporaedOut", :minimum, val, -1, false)
end
if name === Symbol("probabilityAltCalibrated")
OpenAPI.validate_param(name, "FirstLastNameDiasporaedOut", :format, val, "double")
end
if name === Symbol("probabilityAltCalibrated")
OpenAPI.validate_param(name, "FirstLastNameDiasporaedOut", :maximum, val, 1, false)
OpenAPI.validate_param(name, "FirstLastNameDiasporaedOut", :minimum, val, -1, false)
end
end
| NamSor | https://github.com/NeroBlackstone/NamSor.jl.git |
|
[
"MIT"
] | 0.1.0 | 2d6ab091a1f4af72f40a76fe35b2c01982aa0bbf | code | 1669 | # This file was generated by the Julia OpenAPI Code Generator
# Do not modify this file directly. Modify the OpenAPI specification instead.
@doc raw"""FirstLastNameGenderIn
FirstLastNameGenderIn(;
id=nothing,
firstName=nothing,
lastName=nothing,
gender=nothing,
)
- id::String
- firstName::String
- lastName::String
- gender::String : The known gender of the name
"""
Base.@kwdef mutable struct FirstLastNameGenderIn <: OpenAPI.APIModel
id::Union{Nothing, String} = nothing
firstName::Union{Nothing, String} = nothing
lastName::Union{Nothing, String} = nothing
gender::Union{Nothing, String} = nothing
function FirstLastNameGenderIn(id, firstName, lastName, gender, )
OpenAPI.validate_property(FirstLastNameGenderIn, Symbol("id"), id)
OpenAPI.validate_property(FirstLastNameGenderIn, Symbol("firstName"), firstName)
OpenAPI.validate_property(FirstLastNameGenderIn, Symbol("lastName"), lastName)
OpenAPI.validate_property(FirstLastNameGenderIn, Symbol("gender"), gender)
return new(id, firstName, lastName, gender, )
end
end # type FirstLastNameGenderIn
const _property_types_FirstLastNameGenderIn = Dict{Symbol,String}(Symbol("id")=>"String", Symbol("firstName")=>"String", Symbol("lastName")=>"String", Symbol("gender")=>"String", )
OpenAPI.property_type(::Type{ FirstLastNameGenderIn }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_FirstLastNameGenderIn[name]))}
function check_required(o::FirstLastNameGenderIn)
true
end
function OpenAPI.validate_property(::Type{ FirstLastNameGenderIn }, name::Symbol, val)
end
| NamSor | https://github.com/NeroBlackstone/NamSor.jl.git |
|
[
"MIT"
] | 0.1.0 | 2d6ab091a1f4af72f40a76fe35b2c01982aa0bbf | code | 4792 | # This file was generated by the Julia OpenAPI Code Generator
# Do not modify this file directly. Modify the OpenAPI specification instead.
@doc raw"""FirstLastNameGenderedOut
Represents the output of inferring the LIKELY gender from a personal name.
FirstLastNameGenderedOut(;
script=nothing,
id=nothing,
explanation=nothing,
firstName=nothing,
lastName=nothing,
likelyGender=nothing,
genderScale=nothing,
score=nothing,
probabilityCalibrated=nothing,
)
- script::String
- id::String
- explanation::String
- firstName::String : The first name (also known as given name)
- lastName::String : The last name (also known as family name, or surname)
- likelyGender::String : Most likely gender
- genderScale::Float64 : Compatibility to NamSor_v1 Gender Scale M[-1..U..+1]F value.
- score::Float64 : Compatibility to NamSor_v1 Gender score value. Higher score is better, but score is not normalized. Use calibratedProbability if available.
- probabilityCalibrated::Float64 : The calibrated probability for inferred gender to have been guessed correctly. -1 = still calibrating.
"""
Base.@kwdef mutable struct FirstLastNameGenderedOut <: OpenAPI.APIModel
script::Union{Nothing, String} = nothing
id::Union{Nothing, String} = nothing
explanation::Union{Nothing, String} = nothing
firstName::Union{Nothing, String} = nothing
lastName::Union{Nothing, String} = nothing
likelyGender::Union{Nothing, String} = nothing
genderScale::Union{Nothing, Float64} = nothing
score::Union{Nothing, Float64} = nothing
probabilityCalibrated::Union{Nothing, Float64} = nothing
function FirstLastNameGenderedOut(script, id, explanation, firstName, lastName, likelyGender, genderScale, score, probabilityCalibrated, )
OpenAPI.validate_property(FirstLastNameGenderedOut, Symbol("script"), script)
OpenAPI.validate_property(FirstLastNameGenderedOut, Symbol("id"), id)
OpenAPI.validate_property(FirstLastNameGenderedOut, Symbol("explanation"), explanation)
OpenAPI.validate_property(FirstLastNameGenderedOut, Symbol("firstName"), firstName)
OpenAPI.validate_property(FirstLastNameGenderedOut, Symbol("lastName"), lastName)
OpenAPI.validate_property(FirstLastNameGenderedOut, Symbol("likelyGender"), likelyGender)
OpenAPI.validate_property(FirstLastNameGenderedOut, Symbol("genderScale"), genderScale)
OpenAPI.validate_property(FirstLastNameGenderedOut, Symbol("score"), score)
OpenAPI.validate_property(FirstLastNameGenderedOut, Symbol("probabilityCalibrated"), probabilityCalibrated)
return new(script, id, explanation, firstName, lastName, likelyGender, genderScale, score, probabilityCalibrated, )
end
end # type FirstLastNameGenderedOut
const _property_types_FirstLastNameGenderedOut = Dict{Symbol,String}(Symbol("script")=>"String", Symbol("id")=>"String", Symbol("explanation")=>"String", Symbol("firstName")=>"String", Symbol("lastName")=>"String", Symbol("likelyGender")=>"String", Symbol("genderScale")=>"Float64", Symbol("score")=>"Float64", Symbol("probabilityCalibrated")=>"Float64", )
OpenAPI.property_type(::Type{ FirstLastNameGenderedOut }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_FirstLastNameGenderedOut[name]))}
function check_required(o::FirstLastNameGenderedOut)
true
end
function OpenAPI.validate_property(::Type{ FirstLastNameGenderedOut }, name::Symbol, val)
if name === Symbol("likelyGender")
OpenAPI.validate_param(name, "FirstLastNameGenderedOut", :enum, val, ["male", "female", "unknown"])
end
if name === Symbol("genderScale")
OpenAPI.validate_param(name, "FirstLastNameGenderedOut", :format, val, "double")
end
if name === Symbol("genderScale")
OpenAPI.validate_param(name, "FirstLastNameGenderedOut", :maximum, val, 1, false)
OpenAPI.validate_param(name, "FirstLastNameGenderedOut", :minimum, val, -1, false)
end
if name === Symbol("score")
OpenAPI.validate_param(name, "FirstLastNameGenderedOut", :format, val, "double")
end
if name === Symbol("score")
OpenAPI.validate_param(name, "FirstLastNameGenderedOut", :maximum, val, 100, false)
OpenAPI.validate_param(name, "FirstLastNameGenderedOut", :minimum, val, 0, false)
end
if name === Symbol("probabilityCalibrated")
OpenAPI.validate_param(name, "FirstLastNameGenderedOut", :format, val, "double")
end
if name === Symbol("probabilityCalibrated")
OpenAPI.validate_param(name, "FirstLastNameGenderedOut", :maximum, val, 1, false)
OpenAPI.validate_param(name, "FirstLastNameGenderedOut", :minimum, val, -1, false)
end
end
| NamSor | https://github.com/NeroBlackstone/NamSor.jl.git |
|
[
"MIT"
] | 0.1.0 | 2d6ab091a1f4af72f40a76fe35b2c01982aa0bbf | code | 1636 | # This file was generated by the Julia OpenAPI Code Generator
# Do not modify this file directly. Modify the OpenAPI specification instead.
@doc raw"""FirstLastNameGeoIn
FirstLastNameGeoIn(;
id=nothing,
firstName=nothing,
lastName=nothing,
countryIso2=nothing,
)
- id::String
- firstName::String
- lastName::String
- countryIso2::String
"""
Base.@kwdef mutable struct FirstLastNameGeoIn <: OpenAPI.APIModel
id::Union{Nothing, String} = nothing
firstName::Union{Nothing, String} = nothing
lastName::Union{Nothing, String} = nothing
countryIso2::Union{Nothing, String} = nothing
function FirstLastNameGeoIn(id, firstName, lastName, countryIso2, )
OpenAPI.validate_property(FirstLastNameGeoIn, Symbol("id"), id)
OpenAPI.validate_property(FirstLastNameGeoIn, Symbol("firstName"), firstName)
OpenAPI.validate_property(FirstLastNameGeoIn, Symbol("lastName"), lastName)
OpenAPI.validate_property(FirstLastNameGeoIn, Symbol("countryIso2"), countryIso2)
return new(id, firstName, lastName, countryIso2, )
end
end # type FirstLastNameGeoIn
const _property_types_FirstLastNameGeoIn = Dict{Symbol,String}(Symbol("id")=>"String", Symbol("firstName")=>"String", Symbol("lastName")=>"String", Symbol("countryIso2")=>"String", )
OpenAPI.property_type(::Type{ FirstLastNameGeoIn }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_FirstLastNameGeoIn[name]))}
function check_required(o::FirstLastNameGeoIn)
true
end
function OpenAPI.validate_property(::Type{ FirstLastNameGeoIn }, name::Symbol, val)
end
| NamSor | https://github.com/NeroBlackstone/NamSor.jl.git |
|
[
"MIT"
] | 0.1.0 | 2d6ab091a1f4af72f40a76fe35b2c01982aa0bbf | code | 6932 | # This file was generated by the Julia OpenAPI Code Generator
# Do not modify this file directly. Modify the OpenAPI specification instead.
@doc raw"""FirstLastNameGeoOut
Represents the output of inferring the LIKELY country of Origin from a personal name.
FirstLastNameGeoOut(;
script=nothing,
id=nothing,
explanation=nothing,
firstName=nothing,
lastName=nothing,
score=nothing,
country=nothing,
countryAlt=nothing,
region=nothing,
topRegion=nothing,
subRegion=nothing,
countriesTop=nothing,
probabilityCalibrated=nothing,
probabilityAltCalibrated=nothing,
religionStats=nothing,
religionStatsAlt=nothing,
)
- script::String
- id::String
- explanation::String
- firstName::String : The first name (also known as given name)
- lastName::String : The last name (also known as family name, or surname)
- score::Float64 : Higher score is better, but score is not normalized. Use calibratedProbability if available.
- country::String : Most likely country
- countryAlt::String : Second best alternative : country
- region::String : Most likely region (based on country ISO2 code)
- topRegion::String : Most likely top region (based on country ISO2 code)
- subRegion::String : Most likely sub region (based on country ISO2 code)
- countriesTop::Vector{String} : List countries (top 10)
- probabilityCalibrated::Float64 : The calibrated probability for country to have been guessed correctly. -1 = still calibrating.
- probabilityAltCalibrated::Float64 : The calibrated probability for country OR countryAlt to have been guessed correctly. -1 = still calibrating.
- religionStats::Vector{ReligionStatOut} : Geographic religious statistics, assuming country is correctly predicted.
- religionStatsAlt::Vector{ReligionStatOut} : Geographic religious statistics, for country best alternative.
"""
Base.@kwdef mutable struct FirstLastNameGeoOut <: OpenAPI.APIModel
script::Union{Nothing, String} = nothing
id::Union{Nothing, String} = nothing
explanation::Union{Nothing, String} = nothing
firstName::Union{Nothing, String} = nothing
lastName::Union{Nothing, String} = nothing
score::Union{Nothing, Float64} = nothing
country::Union{Nothing, String} = nothing
countryAlt::Union{Nothing, String} = nothing
region::Union{Nothing, String} = nothing
topRegion::Union{Nothing, String} = nothing
subRegion::Union{Nothing, String} = nothing
countriesTop::Union{Nothing, Vector{String}} = nothing
probabilityCalibrated::Union{Nothing, Float64} = nothing
probabilityAltCalibrated::Union{Nothing, Float64} = nothing
religionStats::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{ReligionStatOut} }
religionStatsAlt::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{ReligionStatOut} }
function FirstLastNameGeoOut(script, id, explanation, firstName, lastName, score, country, countryAlt, region, topRegion, subRegion, countriesTop, probabilityCalibrated, probabilityAltCalibrated, religionStats, religionStatsAlt, )
OpenAPI.validate_property(FirstLastNameGeoOut, Symbol("script"), script)
OpenAPI.validate_property(FirstLastNameGeoOut, Symbol("id"), id)
OpenAPI.validate_property(FirstLastNameGeoOut, Symbol("explanation"), explanation)
OpenAPI.validate_property(FirstLastNameGeoOut, Symbol("firstName"), firstName)
OpenAPI.validate_property(FirstLastNameGeoOut, Symbol("lastName"), lastName)
OpenAPI.validate_property(FirstLastNameGeoOut, Symbol("score"), score)
OpenAPI.validate_property(FirstLastNameGeoOut, Symbol("country"), country)
OpenAPI.validate_property(FirstLastNameGeoOut, Symbol("countryAlt"), countryAlt)
OpenAPI.validate_property(FirstLastNameGeoOut, Symbol("region"), region)
OpenAPI.validate_property(FirstLastNameGeoOut, Symbol("topRegion"), topRegion)
OpenAPI.validate_property(FirstLastNameGeoOut, Symbol("subRegion"), subRegion)
OpenAPI.validate_property(FirstLastNameGeoOut, Symbol("countriesTop"), countriesTop)
OpenAPI.validate_property(FirstLastNameGeoOut, Symbol("probabilityCalibrated"), probabilityCalibrated)
OpenAPI.validate_property(FirstLastNameGeoOut, Symbol("probabilityAltCalibrated"), probabilityAltCalibrated)
OpenAPI.validate_property(FirstLastNameGeoOut, Symbol("religionStats"), religionStats)
OpenAPI.validate_property(FirstLastNameGeoOut, Symbol("religionStatsAlt"), religionStatsAlt)
return new(script, id, explanation, firstName, lastName, score, country, countryAlt, region, topRegion, subRegion, countriesTop, probabilityCalibrated, probabilityAltCalibrated, religionStats, religionStatsAlt, )
end
end # type FirstLastNameGeoOut
const _property_types_FirstLastNameGeoOut = Dict{Symbol,String}(Symbol("script")=>"String", Symbol("id")=>"String", Symbol("explanation")=>"String", Symbol("firstName")=>"String", Symbol("lastName")=>"String", Symbol("score")=>"Float64", Symbol("country")=>"String", Symbol("countryAlt")=>"String", Symbol("region")=>"String", Symbol("topRegion")=>"String", Symbol("subRegion")=>"String", Symbol("countriesTop")=>"Vector{String}", Symbol("probabilityCalibrated")=>"Float64", Symbol("probabilityAltCalibrated")=>"Float64", Symbol("religionStats")=>"Vector{ReligionStatOut}", Symbol("religionStatsAlt")=>"Vector{ReligionStatOut}", )
OpenAPI.property_type(::Type{ FirstLastNameGeoOut }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_FirstLastNameGeoOut[name]))}
function check_required(o::FirstLastNameGeoOut)
true
end
function OpenAPI.validate_property(::Type{ FirstLastNameGeoOut }, name::Symbol, val)
if name === Symbol("score")
OpenAPI.validate_param(name, "FirstLastNameGeoOut", :format, val, "double")
end
if name === Symbol("score")
OpenAPI.validate_param(name, "FirstLastNameGeoOut", :maximum, val, 100, false)
OpenAPI.validate_param(name, "FirstLastNameGeoOut", :minimum, val, 0, false)
end
if name === Symbol("probabilityCalibrated")
OpenAPI.validate_param(name, "FirstLastNameGeoOut", :format, val, "double")
end
if name === Symbol("probabilityCalibrated")
OpenAPI.validate_param(name, "FirstLastNameGeoOut", :maximum, val, 1, false)
OpenAPI.validate_param(name, "FirstLastNameGeoOut", :minimum, val, -1, false)
end
if name === Symbol("probabilityAltCalibrated")
OpenAPI.validate_param(name, "FirstLastNameGeoOut", :format, val, "double")
end
if name === Symbol("probabilityAltCalibrated")
OpenAPI.validate_param(name, "FirstLastNameGeoOut", :maximum, val, 1, false)
OpenAPI.validate_param(name, "FirstLastNameGeoOut", :minimum, val, -1, false)
end
end
| NamSor | https://github.com/NeroBlackstone/NamSor.jl.git |
|
[
"MIT"
] | 0.1.0 | 2d6ab091a1f4af72f40a76fe35b2c01982aa0bbf | code | 6408 | # This file was generated by the Julia OpenAPI Code Generator
# Do not modify this file directly. Modify the OpenAPI specification instead.
@doc raw"""FirstLastNameGeoSubclassificationOut
Represents the geographic name origin at a country subclassification level (usually regional or state level).
FirstLastNameGeoSubclassificationOut(;
script=nothing,
id=nothing,
explanation=nothing,
firstName=nothing,
lastName=nothing,
countryIso2=nothing,
subClassification=nothing,
subClassificationAlt=nothing,
subclassificationTop=nothing,
score=nothing,
probabilityCalibrated=nothing,
probabilityAltCalibrated=nothing,
)
- script::String
- id::String
- explanation::String
- firstName::String : The first name (also known as given name)
- lastName::String : The last name (also known as family name, or surname)
- countryIso2::String : The input country ISO2 code
- subClassification::String : Most likely subclassification ISO_3166-2 code
- subClassificationAlt::String : Second best alternative : subclassification ISO_3166-2 code
- subclassificationTop::Vector{String} : List subclassification ISO_3166-2 codes (top 10)
- score::Float64 : Compatibility to NamSor_v1 Origin score value. Higher score is better, but score is not normalized. Use calibratedProbability if available.
- probabilityCalibrated::Float64 : The calibrated probability for subclassification to have been guessed correctly. -1 = still calibrating.
- probabilityAltCalibrated::Float64 : The calibrated probability for subclassification OR subclassificationAlt to have been guessed correctly. -1 = still calibrating.
"""
Base.@kwdef mutable struct FirstLastNameGeoSubclassificationOut <: OpenAPI.APIModel
script::Union{Nothing, String} = nothing
id::Union{Nothing, String} = nothing
explanation::Union{Nothing, String} = nothing
firstName::Union{Nothing, String} = nothing
lastName::Union{Nothing, String} = nothing
countryIso2::Union{Nothing, String} = nothing
subClassification::Union{Nothing, String} = nothing
subClassificationAlt::Union{Nothing, String} = nothing
subclassificationTop::Union{Nothing, Vector{String}} = nothing
score::Union{Nothing, Float64} = nothing
probabilityCalibrated::Union{Nothing, Float64} = nothing
probabilityAltCalibrated::Union{Nothing, Float64} = nothing
function FirstLastNameGeoSubclassificationOut(script, id, explanation, firstName, lastName, countryIso2, subClassification, subClassificationAlt, subclassificationTop, score, probabilityCalibrated, probabilityAltCalibrated, )
OpenAPI.validate_property(FirstLastNameGeoSubclassificationOut, Symbol("script"), script)
OpenAPI.validate_property(FirstLastNameGeoSubclassificationOut, Symbol("id"), id)
OpenAPI.validate_property(FirstLastNameGeoSubclassificationOut, Symbol("explanation"), explanation)
OpenAPI.validate_property(FirstLastNameGeoSubclassificationOut, Symbol("firstName"), firstName)
OpenAPI.validate_property(FirstLastNameGeoSubclassificationOut, Symbol("lastName"), lastName)
OpenAPI.validate_property(FirstLastNameGeoSubclassificationOut, Symbol("countryIso2"), countryIso2)
OpenAPI.validate_property(FirstLastNameGeoSubclassificationOut, Symbol("subClassification"), subClassification)
OpenAPI.validate_property(FirstLastNameGeoSubclassificationOut, Symbol("subClassificationAlt"), subClassificationAlt)
OpenAPI.validate_property(FirstLastNameGeoSubclassificationOut, Symbol("subclassificationTop"), subclassificationTop)
OpenAPI.validate_property(FirstLastNameGeoSubclassificationOut, Symbol("score"), score)
OpenAPI.validate_property(FirstLastNameGeoSubclassificationOut, Symbol("probabilityCalibrated"), probabilityCalibrated)
OpenAPI.validate_property(FirstLastNameGeoSubclassificationOut, Symbol("probabilityAltCalibrated"), probabilityAltCalibrated)
return new(script, id, explanation, firstName, lastName, countryIso2, subClassification, subClassificationAlt, subclassificationTop, score, probabilityCalibrated, probabilityAltCalibrated, )
end
end # type FirstLastNameGeoSubclassificationOut
const _property_types_FirstLastNameGeoSubclassificationOut = Dict{Symbol,String}(Symbol("script")=>"String", Symbol("id")=>"String", Symbol("explanation")=>"String", Symbol("firstName")=>"String", Symbol("lastName")=>"String", Symbol("countryIso2")=>"String", Symbol("subClassification")=>"String", Symbol("subClassificationAlt")=>"String", Symbol("subclassificationTop")=>"Vector{String}", Symbol("score")=>"Float64", Symbol("probabilityCalibrated")=>"Float64", Symbol("probabilityAltCalibrated")=>"Float64", )
OpenAPI.property_type(::Type{ FirstLastNameGeoSubclassificationOut }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_FirstLastNameGeoSubclassificationOut[name]))}
function check_required(o::FirstLastNameGeoSubclassificationOut)
true
end
function OpenAPI.validate_property(::Type{ FirstLastNameGeoSubclassificationOut }, name::Symbol, val)
if name === Symbol("score")
OpenAPI.validate_param(name, "FirstLastNameGeoSubclassificationOut", :format, val, "double")
end
if name === Symbol("score")
OpenAPI.validate_param(name, "FirstLastNameGeoSubclassificationOut", :maximum, val, 100, false)
OpenAPI.validate_param(name, "FirstLastNameGeoSubclassificationOut", :minimum, val, 0, false)
end
if name === Symbol("probabilityCalibrated")
OpenAPI.validate_param(name, "FirstLastNameGeoSubclassificationOut", :format, val, "double")
end
if name === Symbol("probabilityCalibrated")
OpenAPI.validate_param(name, "FirstLastNameGeoSubclassificationOut", :maximum, val, 1, false)
OpenAPI.validate_param(name, "FirstLastNameGeoSubclassificationOut", :minimum, val, -1, false)
end
if name === Symbol("probabilityAltCalibrated")
OpenAPI.validate_param(name, "FirstLastNameGeoSubclassificationOut", :format, val, "double")
end
if name === Symbol("probabilityAltCalibrated")
OpenAPI.validate_param(name, "FirstLastNameGeoSubclassificationOut", :maximum, val, 1, false)
OpenAPI.validate_param(name, "FirstLastNameGeoSubclassificationOut", :minimum, val, -1, false)
end
end
| NamSor | https://github.com/NeroBlackstone/NamSor.jl.git |
|
[
"MIT"
] | 0.1.0 | 2d6ab091a1f4af72f40a76fe35b2c01982aa0bbf | code | 2079 | # This file was generated by the Julia OpenAPI Code Generator
# Do not modify this file directly. Modify the OpenAPI specification instead.
@doc raw"""FirstLastNameGeoSubdivisionIn
FirstLastNameGeoSubdivisionIn(;
id=nothing,
firstName=nothing,
lastName=nothing,
countryIso2=nothing,
subdivisionIso=nothing,
)
- id::String
- firstName::String
- lastName::String
- countryIso2::String
- subdivisionIso::String
"""
Base.@kwdef mutable struct FirstLastNameGeoSubdivisionIn <: OpenAPI.APIModel
id::Union{Nothing, String} = nothing
firstName::Union{Nothing, String} = nothing
lastName::Union{Nothing, String} = nothing
countryIso2::Union{Nothing, String} = nothing
subdivisionIso::Union{Nothing, String} = nothing
function FirstLastNameGeoSubdivisionIn(id, firstName, lastName, countryIso2, subdivisionIso, )
OpenAPI.validate_property(FirstLastNameGeoSubdivisionIn, Symbol("id"), id)
OpenAPI.validate_property(FirstLastNameGeoSubdivisionIn, Symbol("firstName"), firstName)
OpenAPI.validate_property(FirstLastNameGeoSubdivisionIn, Symbol("lastName"), lastName)
OpenAPI.validate_property(FirstLastNameGeoSubdivisionIn, Symbol("countryIso2"), countryIso2)
OpenAPI.validate_property(FirstLastNameGeoSubdivisionIn, Symbol("subdivisionIso"), subdivisionIso)
return new(id, firstName, lastName, countryIso2, subdivisionIso, )
end
end # type FirstLastNameGeoSubdivisionIn
const _property_types_FirstLastNameGeoSubdivisionIn = Dict{Symbol,String}(Symbol("id")=>"String", Symbol("firstName")=>"String", Symbol("lastName")=>"String", Symbol("countryIso2")=>"String", Symbol("subdivisionIso")=>"String", )
OpenAPI.property_type(::Type{ FirstLastNameGeoSubdivisionIn }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_FirstLastNameGeoSubdivisionIn[name]))}
function check_required(o::FirstLastNameGeoSubdivisionIn)
true
end
function OpenAPI.validate_property(::Type{ FirstLastNameGeoSubdivisionIn }, name::Symbol, val)
end
| NamSor | https://github.com/NeroBlackstone/NamSor.jl.git |
|
[
"MIT"
] | 0.1.0 | 2d6ab091a1f4af72f40a76fe35b2c01982aa0bbf | code | 1948 | # This file was generated by the Julia OpenAPI Code Generator
# Do not modify this file directly. Modify the OpenAPI specification instead.
@doc raw"""FirstLastNameGeoZippedIn
FirstLastNameGeoZippedIn(;
id=nothing,
firstName=nothing,
lastName=nothing,
countryIso2=nothing,
zipCode=nothing,
)
- id::String
- firstName::String
- lastName::String
- countryIso2::String
- zipCode::String
"""
Base.@kwdef mutable struct FirstLastNameGeoZippedIn <: OpenAPI.APIModel
id::Union{Nothing, String} = nothing
firstName::Union{Nothing, String} = nothing
lastName::Union{Nothing, String} = nothing
countryIso2::Union{Nothing, String} = nothing
zipCode::Union{Nothing, String} = nothing
function FirstLastNameGeoZippedIn(id, firstName, lastName, countryIso2, zipCode, )
OpenAPI.validate_property(FirstLastNameGeoZippedIn, Symbol("id"), id)
OpenAPI.validate_property(FirstLastNameGeoZippedIn, Symbol("firstName"), firstName)
OpenAPI.validate_property(FirstLastNameGeoZippedIn, Symbol("lastName"), lastName)
OpenAPI.validate_property(FirstLastNameGeoZippedIn, Symbol("countryIso2"), countryIso2)
OpenAPI.validate_property(FirstLastNameGeoZippedIn, Symbol("zipCode"), zipCode)
return new(id, firstName, lastName, countryIso2, zipCode, )
end
end # type FirstLastNameGeoZippedIn
const _property_types_FirstLastNameGeoZippedIn = Dict{Symbol,String}(Symbol("id")=>"String", Symbol("firstName")=>"String", Symbol("lastName")=>"String", Symbol("countryIso2")=>"String", Symbol("zipCode")=>"String", )
OpenAPI.property_type(::Type{ FirstLastNameGeoZippedIn }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_FirstLastNameGeoZippedIn[name]))}
function check_required(o::FirstLastNameGeoZippedIn)
true
end
function OpenAPI.validate_property(::Type{ FirstLastNameGeoZippedIn }, name::Symbol, val)
end
| NamSor | https://github.com/NeroBlackstone/NamSor.jl.git |
|
[
"MIT"
] | 0.1.0 | 2d6ab091a1f4af72f40a76fe35b2c01982aa0bbf | code | 1343 | # This file was generated by the Julia OpenAPI Code Generator
# Do not modify this file directly. Modify the OpenAPI specification instead.
@doc raw"""FirstLastNameIn
FirstLastNameIn(;
id=nothing,
firstName=nothing,
lastName=nothing,
)
- id::String
- firstName::String
- lastName::String
"""
Base.@kwdef mutable struct FirstLastNameIn <: OpenAPI.APIModel
id::Union{Nothing, String} = nothing
firstName::Union{Nothing, String} = nothing
lastName::Union{Nothing, String} = nothing
function FirstLastNameIn(id, firstName, lastName, )
OpenAPI.validate_property(FirstLastNameIn, Symbol("id"), id)
OpenAPI.validate_property(FirstLastNameIn, Symbol("firstName"), firstName)
OpenAPI.validate_property(FirstLastNameIn, Symbol("lastName"), lastName)
return new(id, firstName, lastName, )
end
end # type FirstLastNameIn
const _property_types_FirstLastNameIn = Dict{Symbol,String}(Symbol("id")=>"String", Symbol("firstName")=>"String", Symbol("lastName")=>"String", )
OpenAPI.property_type(::Type{ FirstLastNameIn }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_FirstLastNameIn[name]))}
function check_required(o::FirstLastNameIn)
true
end
function OpenAPI.validate_property(::Type{ FirstLastNameIn }, name::Symbol, val)
end
| NamSor | https://github.com/NeroBlackstone/NamSor.jl.git |
|
[
"MIT"
] | 0.1.0 | 2d6ab091a1f4af72f40a76fe35b2c01982aa0bbf | code | 7545 | # This file was generated by the Julia OpenAPI Code Generator
# Do not modify this file directly. Modify the OpenAPI specification instead.
@doc raw"""FirstLastNameOriginedOut
Represents the output of inferring the LIKELY country of Origin from a personal name.
FirstLastNameOriginedOut(;
script=nothing,
id=nothing,
explanation=nothing,
firstName=nothing,
lastName=nothing,
countryOrigin=nothing,
countryOriginAlt=nothing,
countriesOriginTop=nothing,
score=nothing,
regionOrigin=nothing,
topRegionOrigin=nothing,
subRegionOrigin=nothing,
probabilityCalibrated=nothing,
probabilityAltCalibrated=nothing,
religionStats=nothing,
religionStatsAlt=nothing,
)
- script::String
- id::String
- explanation::String
- firstName::String : The first name (also known as given name)
- lastName::String : The last name (also known as family name, or surname)
- countryOrigin::String : Most likely country of Origin
- countryOriginAlt::String : Second best alternative : country of Origin
- countriesOriginTop::Vector{String} : List countries of Origin (top 10)
- score::Float64 : Compatibility to NamSor_v1 Origin score value. Higher score is better, but score is not normalized. Use calibratedProbability if available.
- regionOrigin::String : Most likely region of Origin (based on countryOrigin ISO2 code)
- topRegionOrigin::String : Most likely top region of Origin (based on countryOrigin ISO2 code)
- subRegionOrigin::String : Most likely sub region of Origin (based on countryOrigin ISO2 code)
- probabilityCalibrated::Float64 : The calibrated probability for countryOrigin to have been guessed correctly. -1 = still calibrating.
- probabilityAltCalibrated::Float64 : The calibrated probability for countryOrigin OR countryOriginAlt to have been guessed correctly. -1 = still calibrating.
- religionStats::Vector{ReligionStatOut} : Geographic religious statistics, assuming country of origin is correctly predicted.
- religionStatsAlt::Vector{ReligionStatOut} : Geographic religious statistics, for origin best alternative.
"""
Base.@kwdef mutable struct FirstLastNameOriginedOut <: OpenAPI.APIModel
script::Union{Nothing, String} = nothing
id::Union{Nothing, String} = nothing
explanation::Union{Nothing, String} = nothing
firstName::Union{Nothing, String} = nothing
lastName::Union{Nothing, String} = nothing
countryOrigin::Union{Nothing, String} = nothing
countryOriginAlt::Union{Nothing, String} = nothing
countriesOriginTop::Union{Nothing, Vector{String}} = nothing
score::Union{Nothing, Float64} = nothing
regionOrigin::Union{Nothing, String} = nothing
topRegionOrigin::Union{Nothing, String} = nothing
subRegionOrigin::Union{Nothing, String} = nothing
probabilityCalibrated::Union{Nothing, Float64} = nothing
probabilityAltCalibrated::Union{Nothing, Float64} = nothing
religionStats::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{ReligionStatOut} }
religionStatsAlt::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{ReligionStatOut} }
function FirstLastNameOriginedOut(script, id, explanation, firstName, lastName, countryOrigin, countryOriginAlt, countriesOriginTop, score, regionOrigin, topRegionOrigin, subRegionOrigin, probabilityCalibrated, probabilityAltCalibrated, religionStats, religionStatsAlt, )
OpenAPI.validate_property(FirstLastNameOriginedOut, Symbol("script"), script)
OpenAPI.validate_property(FirstLastNameOriginedOut, Symbol("id"), id)
OpenAPI.validate_property(FirstLastNameOriginedOut, Symbol("explanation"), explanation)
OpenAPI.validate_property(FirstLastNameOriginedOut, Symbol("firstName"), firstName)
OpenAPI.validate_property(FirstLastNameOriginedOut, Symbol("lastName"), lastName)
OpenAPI.validate_property(FirstLastNameOriginedOut, Symbol("countryOrigin"), countryOrigin)
OpenAPI.validate_property(FirstLastNameOriginedOut, Symbol("countryOriginAlt"), countryOriginAlt)
OpenAPI.validate_property(FirstLastNameOriginedOut, Symbol("countriesOriginTop"), countriesOriginTop)
OpenAPI.validate_property(FirstLastNameOriginedOut, Symbol("score"), score)
OpenAPI.validate_property(FirstLastNameOriginedOut, Symbol("regionOrigin"), regionOrigin)
OpenAPI.validate_property(FirstLastNameOriginedOut, Symbol("topRegionOrigin"), topRegionOrigin)
OpenAPI.validate_property(FirstLastNameOriginedOut, Symbol("subRegionOrigin"), subRegionOrigin)
OpenAPI.validate_property(FirstLastNameOriginedOut, Symbol("probabilityCalibrated"), probabilityCalibrated)
OpenAPI.validate_property(FirstLastNameOriginedOut, Symbol("probabilityAltCalibrated"), probabilityAltCalibrated)
OpenAPI.validate_property(FirstLastNameOriginedOut, Symbol("religionStats"), religionStats)
OpenAPI.validate_property(FirstLastNameOriginedOut, Symbol("religionStatsAlt"), religionStatsAlt)
return new(script, id, explanation, firstName, lastName, countryOrigin, countryOriginAlt, countriesOriginTop, score, regionOrigin, topRegionOrigin, subRegionOrigin, probabilityCalibrated, probabilityAltCalibrated, religionStats, religionStatsAlt, )
end
end # type FirstLastNameOriginedOut
const _property_types_FirstLastNameOriginedOut = Dict{Symbol,String}(Symbol("script")=>"String", Symbol("id")=>"String", Symbol("explanation")=>"String", Symbol("firstName")=>"String", Symbol("lastName")=>"String", Symbol("countryOrigin")=>"String", Symbol("countryOriginAlt")=>"String", Symbol("countriesOriginTop")=>"Vector{String}", Symbol("score")=>"Float64", Symbol("regionOrigin")=>"String", Symbol("topRegionOrigin")=>"String", Symbol("subRegionOrigin")=>"String", Symbol("probabilityCalibrated")=>"Float64", Symbol("probabilityAltCalibrated")=>"Float64", Symbol("religionStats")=>"Vector{ReligionStatOut}", Symbol("religionStatsAlt")=>"Vector{ReligionStatOut}", )
OpenAPI.property_type(::Type{ FirstLastNameOriginedOut }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_FirstLastNameOriginedOut[name]))}
function check_required(o::FirstLastNameOriginedOut)
true
end
function OpenAPI.validate_property(::Type{ FirstLastNameOriginedOut }, name::Symbol, val)
if name === Symbol("score")
OpenAPI.validate_param(name, "FirstLastNameOriginedOut", :format, val, "double")
end
if name === Symbol("score")
OpenAPI.validate_param(name, "FirstLastNameOriginedOut", :maximum, val, 100, false)
OpenAPI.validate_param(name, "FirstLastNameOriginedOut", :minimum, val, 0, false)
end
if name === Symbol("probabilityCalibrated")
OpenAPI.validate_param(name, "FirstLastNameOriginedOut", :format, val, "double")
end
if name === Symbol("probabilityCalibrated")
OpenAPI.validate_param(name, "FirstLastNameOriginedOut", :maximum, val, 1, false)
OpenAPI.validate_param(name, "FirstLastNameOriginedOut", :minimum, val, -1, false)
end
if name === Symbol("probabilityAltCalibrated")
OpenAPI.validate_param(name, "FirstLastNameOriginedOut", :format, val, "double")
end
if name === Symbol("probabilityAltCalibrated")
OpenAPI.validate_param(name, "FirstLastNameOriginedOut", :maximum, val, 1, false)
OpenAPI.validate_param(name, "FirstLastNameOriginedOut", :minimum, val, -1, false)
end
end
| NamSor | https://github.com/NeroBlackstone/NamSor.jl.git |
|
[
"MIT"
] | 0.1.0 | 2d6ab091a1f4af72f40a76fe35b2c01982aa0bbf | code | 1990 | # This file was generated by the Julia OpenAPI Code Generator
# Do not modify this file directly. Modify the OpenAPI specification instead.
@doc raw"""FirstLastNameOut
First / last name structure corresponding to the most likely parsing.
FirstLastNameOut(;
script=nothing,
id=nothing,
explanation=nothing,
firstName=nothing,
lastName=nothing,
)
- script::String
- id::String
- explanation::String
- firstName::String : The first name (also known as given name)
- lastName::String : The last name (also known as family name, or surname)
"""
Base.@kwdef mutable struct FirstLastNameOut <: OpenAPI.APIModel
script::Union{Nothing, String} = nothing
id::Union{Nothing, String} = nothing
explanation::Union{Nothing, String} = nothing
firstName::Union{Nothing, String} = nothing
lastName::Union{Nothing, String} = nothing
function FirstLastNameOut(script, id, explanation, firstName, lastName, )
OpenAPI.validate_property(FirstLastNameOut, Symbol("script"), script)
OpenAPI.validate_property(FirstLastNameOut, Symbol("id"), id)
OpenAPI.validate_property(FirstLastNameOut, Symbol("explanation"), explanation)
OpenAPI.validate_property(FirstLastNameOut, Symbol("firstName"), firstName)
OpenAPI.validate_property(FirstLastNameOut, Symbol("lastName"), lastName)
return new(script, id, explanation, firstName, lastName, )
end
end # type FirstLastNameOut
const _property_types_FirstLastNameOut = Dict{Symbol,String}(Symbol("script")=>"String", Symbol("id")=>"String", Symbol("explanation")=>"String", Symbol("firstName")=>"String", Symbol("lastName")=>"String", )
OpenAPI.property_type(::Type{ FirstLastNameOut }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_FirstLastNameOut[name]))}
function check_required(o::FirstLastNameOut)
true
end
function OpenAPI.validate_property(::Type{ FirstLastNameOut }, name::Symbol, val)
end
| NamSor | https://github.com/NeroBlackstone/NamSor.jl.git |
|
[
"MIT"
] | 0.1.0 | 2d6ab091a1f4af72f40a76fe35b2c01982aa0bbf | code | 7144 | # This file was generated by the Julia OpenAPI Code Generator
# Do not modify this file directly. Modify the OpenAPI specification instead.
@doc raw"""FirstLastNamePhoneCodedOut
Represents the output of inferring the LIKELY country and phone code from a personal name and phone number.
FirstLastNamePhoneCodedOut(;
script=nothing,
id=nothing,
explanation=nothing,
firstName=nothing,
lastName=nothing,
internationalPhoneNumberVerified=nothing,
phoneCountryIso2Verified=nothing,
phoneCountryCode=nothing,
phoneCountryCodeAlt=nothing,
phoneCountryIso2=nothing,
phoneCountryIso2Alt=nothing,
originCountryIso2=nothing,
originCountryIso2Alt=nothing,
phoneNumber=nothing,
verified=nothing,
score=nothing,
countryIso2=nothing,
)
- script::String
- id::String
- explanation::String
- firstName::String : The first name (also known as given name)
- lastName::String : The last name (also known as family name, or surname)
- internationalPhoneNumberVerified::String : The normalized phone number, verified using libphonenumber.
- phoneCountryIso2Verified::String : The phone ISO2 country code, verified using libphonenumber.
- phoneCountryCode::Int64 : The phone country code of the phone number, verified using libphonenumber.
- phoneCountryCodeAlt::Int64 : The best alternative phone country code of the phone number.
- phoneCountryIso2::String : The likely country of the phone number.
- phoneCountryIso2Alt::String : The best alternative country of the phone number.
- originCountryIso2::String : The likely country of origin of the name.
- originCountryIso2Alt::String : The best alternative country of origin of the name.
- phoneNumber::String : The input phone number.
- verified::Bool : Indicates if the phone number could be positively verified using libphonenumber.
- score::Float64 : Higher score is better, but score is not normalized. Use calibratedProbability if available.
- countryIso2::String
"""
Base.@kwdef mutable struct FirstLastNamePhoneCodedOut <: OpenAPI.APIModel
script::Union{Nothing, String} = nothing
id::Union{Nothing, String} = nothing
explanation::Union{Nothing, String} = nothing
firstName::Union{Nothing, String} = nothing
lastName::Union{Nothing, String} = nothing
internationalPhoneNumberVerified::Union{Nothing, String} = nothing
phoneCountryIso2Verified::Union{Nothing, String} = nothing
phoneCountryCode::Union{Nothing, Int64} = nothing
phoneCountryCodeAlt::Union{Nothing, Int64} = nothing
phoneCountryIso2::Union{Nothing, String} = nothing
phoneCountryIso2Alt::Union{Nothing, String} = nothing
originCountryIso2::Union{Nothing, String} = nothing
originCountryIso2Alt::Union{Nothing, String} = nothing
phoneNumber::Union{Nothing, String} = nothing
verified::Union{Nothing, Bool} = nothing
score::Union{Nothing, Float64} = nothing
countryIso2::Union{Nothing, String} = nothing
function FirstLastNamePhoneCodedOut(script, id, explanation, firstName, lastName, internationalPhoneNumberVerified, phoneCountryIso2Verified, phoneCountryCode, phoneCountryCodeAlt, phoneCountryIso2, phoneCountryIso2Alt, originCountryIso2, originCountryIso2Alt, phoneNumber, verified, score, countryIso2, )
OpenAPI.validate_property(FirstLastNamePhoneCodedOut, Symbol("script"), script)
OpenAPI.validate_property(FirstLastNamePhoneCodedOut, Symbol("id"), id)
OpenAPI.validate_property(FirstLastNamePhoneCodedOut, Symbol("explanation"), explanation)
OpenAPI.validate_property(FirstLastNamePhoneCodedOut, Symbol("firstName"), firstName)
OpenAPI.validate_property(FirstLastNamePhoneCodedOut, Symbol("lastName"), lastName)
OpenAPI.validate_property(FirstLastNamePhoneCodedOut, Symbol("internationalPhoneNumberVerified"), internationalPhoneNumberVerified)
OpenAPI.validate_property(FirstLastNamePhoneCodedOut, Symbol("phoneCountryIso2Verified"), phoneCountryIso2Verified)
OpenAPI.validate_property(FirstLastNamePhoneCodedOut, Symbol("phoneCountryCode"), phoneCountryCode)
OpenAPI.validate_property(FirstLastNamePhoneCodedOut, Symbol("phoneCountryCodeAlt"), phoneCountryCodeAlt)
OpenAPI.validate_property(FirstLastNamePhoneCodedOut, Symbol("phoneCountryIso2"), phoneCountryIso2)
OpenAPI.validate_property(FirstLastNamePhoneCodedOut, Symbol("phoneCountryIso2Alt"), phoneCountryIso2Alt)
OpenAPI.validate_property(FirstLastNamePhoneCodedOut, Symbol("originCountryIso2"), originCountryIso2)
OpenAPI.validate_property(FirstLastNamePhoneCodedOut, Symbol("originCountryIso2Alt"), originCountryIso2Alt)
OpenAPI.validate_property(FirstLastNamePhoneCodedOut, Symbol("phoneNumber"), phoneNumber)
OpenAPI.validate_property(FirstLastNamePhoneCodedOut, Symbol("verified"), verified)
OpenAPI.validate_property(FirstLastNamePhoneCodedOut, Symbol("score"), score)
OpenAPI.validate_property(FirstLastNamePhoneCodedOut, Symbol("countryIso2"), countryIso2)
return new(script, id, explanation, firstName, lastName, internationalPhoneNumberVerified, phoneCountryIso2Verified, phoneCountryCode, phoneCountryCodeAlt, phoneCountryIso2, phoneCountryIso2Alt, originCountryIso2, originCountryIso2Alt, phoneNumber, verified, score, countryIso2, )
end
end # type FirstLastNamePhoneCodedOut
const _property_types_FirstLastNamePhoneCodedOut = Dict{Symbol,String}(Symbol("script")=>"String", Symbol("id")=>"String", Symbol("explanation")=>"String", Symbol("firstName")=>"String", Symbol("lastName")=>"String", Symbol("internationalPhoneNumberVerified")=>"String", Symbol("phoneCountryIso2Verified")=>"String", Symbol("phoneCountryCode")=>"Int64", Symbol("phoneCountryCodeAlt")=>"Int64", Symbol("phoneCountryIso2")=>"String", Symbol("phoneCountryIso2Alt")=>"String", Symbol("originCountryIso2")=>"String", Symbol("originCountryIso2Alt")=>"String", Symbol("phoneNumber")=>"String", Symbol("verified")=>"Bool", Symbol("score")=>"Float64", Symbol("countryIso2")=>"String", )
OpenAPI.property_type(::Type{ FirstLastNamePhoneCodedOut }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_FirstLastNamePhoneCodedOut[name]))}
function check_required(o::FirstLastNamePhoneCodedOut)
true
end
function OpenAPI.validate_property(::Type{ FirstLastNamePhoneCodedOut }, name::Symbol, val)
if name === Symbol("phoneCountryCode")
OpenAPI.validate_param(name, "FirstLastNamePhoneCodedOut", :format, val, "int32")
end
if name === Symbol("phoneCountryCodeAlt")
OpenAPI.validate_param(name, "FirstLastNamePhoneCodedOut", :format, val, "int32")
end
if name === Symbol("score")
OpenAPI.validate_param(name, "FirstLastNamePhoneCodedOut", :format, val, "double")
end
if name === Symbol("score")
OpenAPI.validate_param(name, "FirstLastNamePhoneCodedOut", :maximum, val, 100, false)
OpenAPI.validate_param(name, "FirstLastNamePhoneCodedOut", :minimum, val, 0, false)
end
end
| NamSor | https://github.com/NeroBlackstone/NamSor.jl.git |
|
[
"MIT"
] | 0.1.0 | 2d6ab091a1f4af72f40a76fe35b2c01982aa0bbf | code | 2344 | # This file was generated by the Julia OpenAPI Code Generator
# Do not modify this file directly. Modify the OpenAPI specification instead.
@doc raw"""FirstLastNamePhoneNumberGeoIn
FirstLastNamePhoneNumberGeoIn(;
id=nothing,
firstName=nothing,
lastName=nothing,
phoneNumber=nothing,
countryIso2=nothing,
countryIso2Alt=nothing,
)
- id::String
- firstName::String
- lastName::String
- phoneNumber::String
- countryIso2::String
- countryIso2Alt::String
"""
Base.@kwdef mutable struct FirstLastNamePhoneNumberGeoIn <: OpenAPI.APIModel
id::Union{Nothing, String} = nothing
firstName::Union{Nothing, String} = nothing
lastName::Union{Nothing, String} = nothing
phoneNumber::Union{Nothing, String} = nothing
countryIso2::Union{Nothing, String} = nothing
countryIso2Alt::Union{Nothing, String} = nothing
function FirstLastNamePhoneNumberGeoIn(id, firstName, lastName, phoneNumber, countryIso2, countryIso2Alt, )
OpenAPI.validate_property(FirstLastNamePhoneNumberGeoIn, Symbol("id"), id)
OpenAPI.validate_property(FirstLastNamePhoneNumberGeoIn, Symbol("firstName"), firstName)
OpenAPI.validate_property(FirstLastNamePhoneNumberGeoIn, Symbol("lastName"), lastName)
OpenAPI.validate_property(FirstLastNamePhoneNumberGeoIn, Symbol("phoneNumber"), phoneNumber)
OpenAPI.validate_property(FirstLastNamePhoneNumberGeoIn, Symbol("countryIso2"), countryIso2)
OpenAPI.validate_property(FirstLastNamePhoneNumberGeoIn, Symbol("countryIso2Alt"), countryIso2Alt)
return new(id, firstName, lastName, phoneNumber, countryIso2, countryIso2Alt, )
end
end # type FirstLastNamePhoneNumberGeoIn
const _property_types_FirstLastNamePhoneNumberGeoIn = Dict{Symbol,String}(Symbol("id")=>"String", Symbol("firstName")=>"String", Symbol("lastName")=>"String", Symbol("phoneNumber")=>"String", Symbol("countryIso2")=>"String", Symbol("countryIso2Alt")=>"String", )
OpenAPI.property_type(::Type{ FirstLastNamePhoneNumberGeoIn }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_FirstLastNamePhoneNumberGeoIn[name]))}
function check_required(o::FirstLastNamePhoneNumberGeoIn)
true
end
function OpenAPI.validate_property(::Type{ FirstLastNamePhoneNumberGeoIn }, name::Symbol, val)
end
| NamSor | https://github.com/NeroBlackstone/NamSor.jl.git |
|
[
"MIT"
] | 0.1.0 | 2d6ab091a1f4af72f40a76fe35b2c01982aa0bbf | code | 1748 | # This file was generated by the Julia OpenAPI Code Generator
# Do not modify this file directly. Modify the OpenAPI specification instead.
@doc raw"""FirstLastNamePhoneNumberIn
FirstLastNamePhoneNumberIn(;
id=nothing,
firstName=nothing,
lastName=nothing,
phoneNumber=nothing,
)
- id::String
- firstName::String
- lastName::String
- phoneNumber::String
"""
Base.@kwdef mutable struct FirstLastNamePhoneNumberIn <: OpenAPI.APIModel
id::Union{Nothing, String} = nothing
firstName::Union{Nothing, String} = nothing
lastName::Union{Nothing, String} = nothing
phoneNumber::Union{Nothing, String} = nothing
function FirstLastNamePhoneNumberIn(id, firstName, lastName, phoneNumber, )
OpenAPI.validate_property(FirstLastNamePhoneNumberIn, Symbol("id"), id)
OpenAPI.validate_property(FirstLastNamePhoneNumberIn, Symbol("firstName"), firstName)
OpenAPI.validate_property(FirstLastNamePhoneNumberIn, Symbol("lastName"), lastName)
OpenAPI.validate_property(FirstLastNamePhoneNumberIn, Symbol("phoneNumber"), phoneNumber)
return new(id, firstName, lastName, phoneNumber, )
end
end # type FirstLastNamePhoneNumberIn
const _property_types_FirstLastNamePhoneNumberIn = Dict{Symbol,String}(Symbol("id")=>"String", Symbol("firstName")=>"String", Symbol("lastName")=>"String", Symbol("phoneNumber")=>"String", )
OpenAPI.property_type(::Type{ FirstLastNamePhoneNumberIn }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_FirstLastNamePhoneNumberIn[name]))}
function check_required(o::FirstLastNamePhoneNumberIn)
true
end
function OpenAPI.validate_property(::Type{ FirstLastNamePhoneNumberIn }, name::Symbol, val)
end
| NamSor | https://github.com/NeroBlackstone/NamSor.jl.git |
|
[
"MIT"
] | 0.1.0 | 2d6ab091a1f4af72f40a76fe35b2c01982aa0bbf | code | 5473 | # This file was generated by the Julia OpenAPI Code Generator
# Do not modify this file directly. Modify the OpenAPI specification instead.
@doc raw"""FirstLastNameReligionedOut
Represents the output of inferring the LIKELY religion from a personal Indian first/last name.
FirstLastNameReligionedOut(;
script=nothing,
id=nothing,
explanation=nothing,
firstName=nothing,
lastName=nothing,
religion=nothing,
religionAlt=nothing,
religionsTop=nothing,
score=nothing,
probabilityCalibrated=nothing,
probabilityAltCalibrated=nothing,
)
- script::String
- id::String
- explanation::String
- firstName::String : The first name (also known as given name)
- lastName::String : The last name (also known as family name, or surname)
- religion::String : Most likely religion
- religionAlt::String : Second best alternative : religion
- religionsTop::Vector{String} : List countries (top 10)
- score::Float64 : Compatibility to NamSor_v1 Origin score value. Higher score is better, but score is not normalized. Use calibratedProbability if available.
- probabilityCalibrated::Float64 : The calibrated probability for caste to have been guessed correctly. -1 = still calibrating.
- probabilityAltCalibrated::Float64 : The calibrated probability for caste OR casteAlt to have been guessed correctly. -1 = still calibrating.
"""
Base.@kwdef mutable struct FirstLastNameReligionedOut <: OpenAPI.APIModel
script::Union{Nothing, String} = nothing
id::Union{Nothing, String} = nothing
explanation::Union{Nothing, String} = nothing
firstName::Union{Nothing, String} = nothing
lastName::Union{Nothing, String} = nothing
religion::Union{Nothing, String} = nothing
religionAlt::Union{Nothing, String} = nothing
religionsTop::Union{Nothing, Vector{String}} = nothing
score::Union{Nothing, Float64} = nothing
probabilityCalibrated::Union{Nothing, Float64} = nothing
probabilityAltCalibrated::Union{Nothing, Float64} = nothing
function FirstLastNameReligionedOut(script, id, explanation, firstName, lastName, religion, religionAlt, religionsTop, score, probabilityCalibrated, probabilityAltCalibrated, )
OpenAPI.validate_property(FirstLastNameReligionedOut, Symbol("script"), script)
OpenAPI.validate_property(FirstLastNameReligionedOut, Symbol("id"), id)
OpenAPI.validate_property(FirstLastNameReligionedOut, Symbol("explanation"), explanation)
OpenAPI.validate_property(FirstLastNameReligionedOut, Symbol("firstName"), firstName)
OpenAPI.validate_property(FirstLastNameReligionedOut, Symbol("lastName"), lastName)
OpenAPI.validate_property(FirstLastNameReligionedOut, Symbol("religion"), religion)
OpenAPI.validate_property(FirstLastNameReligionedOut, Symbol("religionAlt"), religionAlt)
OpenAPI.validate_property(FirstLastNameReligionedOut, Symbol("religionsTop"), religionsTop)
OpenAPI.validate_property(FirstLastNameReligionedOut, Symbol("score"), score)
OpenAPI.validate_property(FirstLastNameReligionedOut, Symbol("probabilityCalibrated"), probabilityCalibrated)
OpenAPI.validate_property(FirstLastNameReligionedOut, Symbol("probabilityAltCalibrated"), probabilityAltCalibrated)
return new(script, id, explanation, firstName, lastName, religion, religionAlt, religionsTop, score, probabilityCalibrated, probabilityAltCalibrated, )
end
end # type FirstLastNameReligionedOut
const _property_types_FirstLastNameReligionedOut = Dict{Symbol,String}(Symbol("script")=>"String", Symbol("id")=>"String", Symbol("explanation")=>"String", Symbol("firstName")=>"String", Symbol("lastName")=>"String", Symbol("religion")=>"String", Symbol("religionAlt")=>"String", Symbol("religionsTop")=>"Vector{String}", Symbol("score")=>"Float64", Symbol("probabilityCalibrated")=>"Float64", Symbol("probabilityAltCalibrated")=>"Float64", )
OpenAPI.property_type(::Type{ FirstLastNameReligionedOut }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_FirstLastNameReligionedOut[name]))}
function check_required(o::FirstLastNameReligionedOut)
true
end
function OpenAPI.validate_property(::Type{ FirstLastNameReligionedOut }, name::Symbol, val)
if name === Symbol("score")
OpenAPI.validate_param(name, "FirstLastNameReligionedOut", :format, val, "double")
end
if name === Symbol("score")
OpenAPI.validate_param(name, "FirstLastNameReligionedOut", :maximum, val, 100, false)
OpenAPI.validate_param(name, "FirstLastNameReligionedOut", :minimum, val, 0, false)
end
if name === Symbol("probabilityCalibrated")
OpenAPI.validate_param(name, "FirstLastNameReligionedOut", :format, val, "double")
end
if name === Symbol("probabilityCalibrated")
OpenAPI.validate_param(name, "FirstLastNameReligionedOut", :maximum, val, 1, false)
OpenAPI.validate_param(name, "FirstLastNameReligionedOut", :minimum, val, -1, false)
end
if name === Symbol("probabilityAltCalibrated")
OpenAPI.validate_param(name, "FirstLastNameReligionedOut", :format, val, "double")
end
if name === Symbol("probabilityAltCalibrated")
OpenAPI.validate_param(name, "FirstLastNameReligionedOut", :maximum, val, 1, false)
OpenAPI.validate_param(name, "FirstLastNameReligionedOut", :minimum, val, -1, false)
end
end
| NamSor | https://github.com/NeroBlackstone/NamSor.jl.git |
|
[
"MIT"
] | 0.1.0 | 2d6ab091a1f4af72f40a76fe35b2c01982aa0bbf | code | 1772 | # This file was generated by the Julia OpenAPI Code Generator
# Do not modify this file directly. Modify the OpenAPI specification instead.
@doc raw"""FirstLastNameSubdivisionIn
FirstLastNameSubdivisionIn(;
id=nothing,
firstName=nothing,
lastName=nothing,
subdivisionIso=nothing,
)
- id::String
- firstName::String
- lastName::String
- subdivisionIso::String
"""
Base.@kwdef mutable struct FirstLastNameSubdivisionIn <: OpenAPI.APIModel
id::Union{Nothing, String} = nothing
firstName::Union{Nothing, String} = nothing
lastName::Union{Nothing, String} = nothing
subdivisionIso::Union{Nothing, String} = nothing
function FirstLastNameSubdivisionIn(id, firstName, lastName, subdivisionIso, )
OpenAPI.validate_property(FirstLastNameSubdivisionIn, Symbol("id"), id)
OpenAPI.validate_property(FirstLastNameSubdivisionIn, Symbol("firstName"), firstName)
OpenAPI.validate_property(FirstLastNameSubdivisionIn, Symbol("lastName"), lastName)
OpenAPI.validate_property(FirstLastNameSubdivisionIn, Symbol("subdivisionIso"), subdivisionIso)
return new(id, firstName, lastName, subdivisionIso, )
end
end # type FirstLastNameSubdivisionIn
const _property_types_FirstLastNameSubdivisionIn = Dict{Symbol,String}(Symbol("id")=>"String", Symbol("firstName")=>"String", Symbol("lastName")=>"String", Symbol("subdivisionIso")=>"String", )
OpenAPI.property_type(::Type{ FirstLastNameSubdivisionIn }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_FirstLastNameSubdivisionIn[name]))}
function check_required(o::FirstLastNameSubdivisionIn)
true
end
function OpenAPI.validate_property(::Type{ FirstLastNameSubdivisionIn }, name::Symbol, val)
end
| NamSor | https://github.com/NeroBlackstone/NamSor.jl.git |
|
[
"MIT"
] | 0.1.0 | 2d6ab091a1f4af72f40a76fe35b2c01982aa0bbf | code | 6182 | # This file was generated by the Julia OpenAPI Code Generator
# Do not modify this file directly. Modify the OpenAPI specification instead.
@doc raw"""FirstLastNameUSRaceEthnicityOut
Represents the output of inferring the LIKELY US 'race/ethnicity' from a personal name, given US country of residence and (optionally) a ZIP5 code.
FirstLastNameUSRaceEthnicityOut(;
script=nothing,
id=nothing,
explanation=nothing,
firstName=nothing,
lastName=nothing,
raceEthnicityAlt=nothing,
raceEthnicity=nothing,
score=nothing,
raceEthnicitiesTop=nothing,
probabilityCalibrated=nothing,
probabilityAltCalibrated=nothing,
)
- script::String
- id::String
- explanation::String
- firstName::String : The first name (also known as given name)
- lastName::String : The last name (also known as family name, or surname)
- raceEthnicityAlt::String : Second most likely US 'race'/ethnicity
- raceEthnicity::String : Most likely US 'race'/ethnicity
- score::Float64 : Higher score is better, but score is not normalized. Use calibratedProbability if available.
- raceEthnicitiesTop::Vector{String} : List 'race'/ethnicities
- probabilityCalibrated::Float64 : The calibrated probability for raceEthnicity to have been guessed correctly. -1 = still calibrating.
- probabilityAltCalibrated::Float64 : The calibrated probability for raceEthnicity OR raceEthnicityAlt to have been guessed correctly. -1 = still calibrating.
"""
Base.@kwdef mutable struct FirstLastNameUSRaceEthnicityOut <: OpenAPI.APIModel
script::Union{Nothing, String} = nothing
id::Union{Nothing, String} = nothing
explanation::Union{Nothing, String} = nothing
firstName::Union{Nothing, String} = nothing
lastName::Union{Nothing, String} = nothing
raceEthnicityAlt::Union{Nothing, String} = nothing
raceEthnicity::Union{Nothing, String} = nothing
score::Union{Nothing, Float64} = nothing
raceEthnicitiesTop::Union{Nothing, Vector{String}} = nothing
probabilityCalibrated::Union{Nothing, Float64} = nothing
probabilityAltCalibrated::Union{Nothing, Float64} = nothing
function FirstLastNameUSRaceEthnicityOut(script, id, explanation, firstName, lastName, raceEthnicityAlt, raceEthnicity, score, raceEthnicitiesTop, probabilityCalibrated, probabilityAltCalibrated, )
OpenAPI.validate_property(FirstLastNameUSRaceEthnicityOut, Symbol("script"), script)
OpenAPI.validate_property(FirstLastNameUSRaceEthnicityOut, Symbol("id"), id)
OpenAPI.validate_property(FirstLastNameUSRaceEthnicityOut, Symbol("explanation"), explanation)
OpenAPI.validate_property(FirstLastNameUSRaceEthnicityOut, Symbol("firstName"), firstName)
OpenAPI.validate_property(FirstLastNameUSRaceEthnicityOut, Symbol("lastName"), lastName)
OpenAPI.validate_property(FirstLastNameUSRaceEthnicityOut, Symbol("raceEthnicityAlt"), raceEthnicityAlt)
OpenAPI.validate_property(FirstLastNameUSRaceEthnicityOut, Symbol("raceEthnicity"), raceEthnicity)
OpenAPI.validate_property(FirstLastNameUSRaceEthnicityOut, Symbol("score"), score)
OpenAPI.validate_property(FirstLastNameUSRaceEthnicityOut, Symbol("raceEthnicitiesTop"), raceEthnicitiesTop)
OpenAPI.validate_property(FirstLastNameUSRaceEthnicityOut, Symbol("probabilityCalibrated"), probabilityCalibrated)
OpenAPI.validate_property(FirstLastNameUSRaceEthnicityOut, Symbol("probabilityAltCalibrated"), probabilityAltCalibrated)
return new(script, id, explanation, firstName, lastName, raceEthnicityAlt, raceEthnicity, score, raceEthnicitiesTop, probabilityCalibrated, probabilityAltCalibrated, )
end
end # type FirstLastNameUSRaceEthnicityOut
const _property_types_FirstLastNameUSRaceEthnicityOut = Dict{Symbol,String}(Symbol("script")=>"String", Symbol("id")=>"String", Symbol("explanation")=>"String", Symbol("firstName")=>"String", Symbol("lastName")=>"String", Symbol("raceEthnicityAlt")=>"String", Symbol("raceEthnicity")=>"String", Symbol("score")=>"Float64", Symbol("raceEthnicitiesTop")=>"Vector{String}", Symbol("probabilityCalibrated")=>"Float64", Symbol("probabilityAltCalibrated")=>"Float64", )
OpenAPI.property_type(::Type{ FirstLastNameUSRaceEthnicityOut }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_FirstLastNameUSRaceEthnicityOut[name]))}
function check_required(o::FirstLastNameUSRaceEthnicityOut)
true
end
function OpenAPI.validate_property(::Type{ FirstLastNameUSRaceEthnicityOut }, name::Symbol, val)
if name === Symbol("raceEthnicityAlt")
OpenAPI.validate_param(name, "FirstLastNameUSRaceEthnicityOut", :enum, val, ["W_NL", "HL", "A", "B_NL", "AI_AN", "PI"])
end
if name === Symbol("raceEthnicity")
OpenAPI.validate_param(name, "FirstLastNameUSRaceEthnicityOut", :enum, val, ["W_NL", "HL", "A", "B_NL", "AI_AN", "PI"])
end
if name === Symbol("score")
OpenAPI.validate_param(name, "FirstLastNameUSRaceEthnicityOut", :format, val, "double")
end
if name === Symbol("score")
OpenAPI.validate_param(name, "FirstLastNameUSRaceEthnicityOut", :maximum, val, 100, false)
OpenAPI.validate_param(name, "FirstLastNameUSRaceEthnicityOut", :minimum, val, 0, false)
end
if name === Symbol("probabilityCalibrated")
OpenAPI.validate_param(name, "FirstLastNameUSRaceEthnicityOut", :format, val, "double")
end
if name === Symbol("probabilityCalibrated")
OpenAPI.validate_param(name, "FirstLastNameUSRaceEthnicityOut", :maximum, val, 1, false)
OpenAPI.validate_param(name, "FirstLastNameUSRaceEthnicityOut", :minimum, val, -1, false)
end
if name === Symbol("probabilityAltCalibrated")
OpenAPI.validate_param(name, "FirstLastNameUSRaceEthnicityOut", :format, val, "double")
end
if name === Symbol("probabilityAltCalibrated")
OpenAPI.validate_param(name, "FirstLastNameUSRaceEthnicityOut", :maximum, val, 1, false)
OpenAPI.validate_param(name, "FirstLastNameUSRaceEthnicityOut", :minimum, val, -1, false)
end
end
| NamSor | https://github.com/NeroBlackstone/NamSor.jl.git |
|
[
"MIT"
] | 0.1.0 | 2d6ab091a1f4af72f40a76fe35b2c01982aa0bbf | code | 1535 | # This file was generated by the Julia OpenAPI Code Generator
# Do not modify this file directly. Modify the OpenAPI specification instead.
@doc raw"""MatchPersonalFirstLastNameIn
MatchPersonalFirstLastNameIn(;
id=nothing,
name1=nothing,
name2=nothing,
)
- id::String
- name1::FirstLastNameIn
- name2::PersonalNameIn
"""
Base.@kwdef mutable struct MatchPersonalFirstLastNameIn <: OpenAPI.APIModel
id::Union{Nothing, String} = nothing
name1 = nothing # spec type: Union{ Nothing, FirstLastNameIn }
name2 = nothing # spec type: Union{ Nothing, PersonalNameIn }
function MatchPersonalFirstLastNameIn(id, name1, name2, )
OpenAPI.validate_property(MatchPersonalFirstLastNameIn, Symbol("id"), id)
OpenAPI.validate_property(MatchPersonalFirstLastNameIn, Symbol("name1"), name1)
OpenAPI.validate_property(MatchPersonalFirstLastNameIn, Symbol("name2"), name2)
return new(id, name1, name2, )
end
end # type MatchPersonalFirstLastNameIn
const _property_types_MatchPersonalFirstLastNameIn = Dict{Symbol,String}(Symbol("id")=>"String", Symbol("name1")=>"FirstLastNameIn", Symbol("name2")=>"PersonalNameIn", )
OpenAPI.property_type(::Type{ MatchPersonalFirstLastNameIn }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_MatchPersonalFirstLastNameIn[name]))}
function check_required(o::MatchPersonalFirstLastNameIn)
true
end
function OpenAPI.validate_property(::Type{ MatchPersonalFirstLastNameIn }, name::Symbol, val)
end
| NamSor | https://github.com/NeroBlackstone/NamSor.jl.git |
|
[
"MIT"
] | 0.1.0 | 2d6ab091a1f4af72f40a76fe35b2c01982aa0bbf | code | 1249 | # This file was generated by the Julia OpenAPI Code Generator
# Do not modify this file directly. Modify the OpenAPI specification instead.
@doc raw"""NameGeoIn
NameGeoIn(;
id=nothing,
name=nothing,
countryIso2=nothing,
)
- id::String
- name::String
- countryIso2::String
"""
Base.@kwdef mutable struct NameGeoIn <: OpenAPI.APIModel
id::Union{Nothing, String} = nothing
name::Union{Nothing, String} = nothing
countryIso2::Union{Nothing, String} = nothing
function NameGeoIn(id, name, countryIso2, )
OpenAPI.validate_property(NameGeoIn, Symbol("id"), id)
OpenAPI.validate_property(NameGeoIn, Symbol("name"), name)
OpenAPI.validate_property(NameGeoIn, Symbol("countryIso2"), countryIso2)
return new(id, name, countryIso2, )
end
end # type NameGeoIn
const _property_types_NameGeoIn = Dict{Symbol,String}(Symbol("id")=>"String", Symbol("name")=>"String", Symbol("countryIso2")=>"String", )
OpenAPI.property_type(::Type{ NameGeoIn }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_NameGeoIn[name]))}
function check_required(o::NameGeoIn)
true
end
function OpenAPI.validate_property(::Type{ NameGeoIn }, name::Symbol, val)
end
| NamSor | https://github.com/NeroBlackstone/NamSor.jl.git |
|
[
"MIT"
] | 0.1.0 | 2d6ab091a1f4af72f40a76fe35b2c01982aa0bbf | code | 968 | # This file was generated by the Julia OpenAPI Code Generator
# Do not modify this file directly. Modify the OpenAPI specification instead.
@doc raw"""NameIn
NameIn(;
id=nothing,
name=nothing,
)
- id::String
- name::String
"""
Base.@kwdef mutable struct NameIn <: OpenAPI.APIModel
id::Union{Nothing, String} = nothing
name::Union{Nothing, String} = nothing
function NameIn(id, name, )
OpenAPI.validate_property(NameIn, Symbol("id"), id)
OpenAPI.validate_property(NameIn, Symbol("name"), name)
return new(id, name, )
end
end # type NameIn
const _property_types_NameIn = Dict{Symbol,String}(Symbol("id")=>"String", Symbol("name")=>"String", )
OpenAPI.property_type(::Type{ NameIn }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_NameIn[name]))}
function check_required(o::NameIn)
true
end
function OpenAPI.validate_property(::Type{ NameIn }, name::Symbol, val)
end
| NamSor | https://github.com/NeroBlackstone/NamSor.jl.git |
|
[
"MIT"
] | 0.1.0 | 2d6ab091a1f4af72f40a76fe35b2c01982aa0bbf | code | 2540 | # This file was generated by the Julia OpenAPI Code Generator
# Do not modify this file directly. Modify the OpenAPI specification instead.
@doc raw"""NameMatchCandidateOut
The ordered list of name matching candidates
NameMatchCandidateOut(;
candidateName=nothing,
probability=nothing,
predScoreGivenName=nothing,
predScoreFamilyName=nothing,
)
- candidateName::String : The name matching candidate name
- probability::Float64 : The name matching estimated probability.
- predScoreGivenName::Float64 : The given name prediction score.
- predScoreFamilyName::Float64 : The family name prediction score.
"""
Base.@kwdef mutable struct NameMatchCandidateOut <: OpenAPI.APIModel
candidateName::Union{Nothing, String} = nothing
probability::Union{Nothing, Float64} = nothing
predScoreGivenName::Union{Nothing, Float64} = nothing
predScoreFamilyName::Union{Nothing, Float64} = nothing
function NameMatchCandidateOut(candidateName, probability, predScoreGivenName, predScoreFamilyName, )
OpenAPI.validate_property(NameMatchCandidateOut, Symbol("candidateName"), candidateName)
OpenAPI.validate_property(NameMatchCandidateOut, Symbol("probability"), probability)
OpenAPI.validate_property(NameMatchCandidateOut, Symbol("predScoreGivenName"), predScoreGivenName)
OpenAPI.validate_property(NameMatchCandidateOut, Symbol("predScoreFamilyName"), predScoreFamilyName)
return new(candidateName, probability, predScoreGivenName, predScoreFamilyName, )
end
end # type NameMatchCandidateOut
const _property_types_NameMatchCandidateOut = Dict{Symbol,String}(Symbol("candidateName")=>"String", Symbol("probability")=>"Float64", Symbol("predScoreGivenName")=>"Float64", Symbol("predScoreFamilyName")=>"Float64", )
OpenAPI.property_type(::Type{ NameMatchCandidateOut }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_NameMatchCandidateOut[name]))}
function check_required(o::NameMatchCandidateOut)
true
end
function OpenAPI.validate_property(::Type{ NameMatchCandidateOut }, name::Symbol, val)
if name === Symbol("probability")
OpenAPI.validate_param(name, "NameMatchCandidateOut", :format, val, "double")
end
if name === Symbol("predScoreGivenName")
OpenAPI.validate_param(name, "NameMatchCandidateOut", :format, val, "double")
end
if name === Symbol("predScoreFamilyName")
OpenAPI.validate_param(name, "NameMatchCandidateOut", :format, val, "double")
end
end
| NamSor | https://github.com/NeroBlackstone/NamSor.jl.git |
|
[
"MIT"
] | 0.1.0 | 2d6ab091a1f4af72f40a76fe35b2c01982aa0bbf | code | 2763 | # This file was generated by the Julia OpenAPI Code Generator
# Do not modify this file directly. Modify the OpenAPI specification instead.
@doc raw"""NameMatchCandidatesOut
Classified matched names
NameMatchCandidatesOut(;
script=nothing,
id=nothing,
explanation=nothing,
firstName=nothing,
lastName=nothing,
orderOption=nothing,
matchCandidates=nothing,
)
- script::String
- id::String
- explanation::String
- firstName::String : The first name (also known as given name)
- lastName::String : The last name (also known as family name, or surname)
- orderOption::String : The option for ordering
- matchCandidates::Vector{NameMatchCandidateOut} : The ordered list of name matching candidates
"""
Base.@kwdef mutable struct NameMatchCandidatesOut <: OpenAPI.APIModel
script::Union{Nothing, String} = nothing
id::Union{Nothing, String} = nothing
explanation::Union{Nothing, String} = nothing
firstName::Union{Nothing, String} = nothing
lastName::Union{Nothing, String} = nothing
orderOption::Union{Nothing, String} = nothing
matchCandidates::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{NameMatchCandidateOut} }
function NameMatchCandidatesOut(script, id, explanation, firstName, lastName, orderOption, matchCandidates, )
OpenAPI.validate_property(NameMatchCandidatesOut, Symbol("script"), script)
OpenAPI.validate_property(NameMatchCandidatesOut, Symbol("id"), id)
OpenAPI.validate_property(NameMatchCandidatesOut, Symbol("explanation"), explanation)
OpenAPI.validate_property(NameMatchCandidatesOut, Symbol("firstName"), firstName)
OpenAPI.validate_property(NameMatchCandidatesOut, Symbol("lastName"), lastName)
OpenAPI.validate_property(NameMatchCandidatesOut, Symbol("orderOption"), orderOption)
OpenAPI.validate_property(NameMatchCandidatesOut, Symbol("matchCandidates"), matchCandidates)
return new(script, id, explanation, firstName, lastName, orderOption, matchCandidates, )
end
end # type NameMatchCandidatesOut
const _property_types_NameMatchCandidatesOut = Dict{Symbol,String}(Symbol("script")=>"String", Symbol("id")=>"String", Symbol("explanation")=>"String", Symbol("firstName")=>"String", Symbol("lastName")=>"String", Symbol("orderOption")=>"String", Symbol("matchCandidates")=>"Vector{NameMatchCandidateOut}", )
OpenAPI.property_type(::Type{ NameMatchCandidatesOut }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_NameMatchCandidatesOut[name]))}
function check_required(o::NameMatchCandidatesOut)
true
end
function OpenAPI.validate_property(::Type{ NameMatchCandidatesOut }, name::Symbol, val)
end
| NamSor | https://github.com/NeroBlackstone/NamSor.jl.git |
|
[
"MIT"
] | 0.1.0 | 2d6ab091a1f4af72f40a76fe35b2c01982aa0bbf | code | 2093 | # This file was generated by the Julia OpenAPI Code Generator
# Do not modify this file directly. Modify the OpenAPI specification instead.
@doc raw"""NameMatchedOut
Classified matched names
NameMatchedOut(;
script=nothing,
id=nothing,
explanation=nothing,
matchStatus=nothing,
score=nothing,
)
- script::String
- id::String
- explanation::String
- matchStatus::String : The name matching status.
- score::Float64
"""
Base.@kwdef mutable struct NameMatchedOut <: OpenAPI.APIModel
script::Union{Nothing, String} = nothing
id::Union{Nothing, String} = nothing
explanation::Union{Nothing, String} = nothing
matchStatus::Union{Nothing, String} = nothing
score::Union{Nothing, Float64} = nothing
function NameMatchedOut(script, id, explanation, matchStatus, score, )
OpenAPI.validate_property(NameMatchedOut, Symbol("script"), script)
OpenAPI.validate_property(NameMatchedOut, Symbol("id"), id)
OpenAPI.validate_property(NameMatchedOut, Symbol("explanation"), explanation)
OpenAPI.validate_property(NameMatchedOut, Symbol("matchStatus"), matchStatus)
OpenAPI.validate_property(NameMatchedOut, Symbol("score"), score)
return new(script, id, explanation, matchStatus, score, )
end
end # type NameMatchedOut
const _property_types_NameMatchedOut = Dict{Symbol,String}(Symbol("script")=>"String", Symbol("id")=>"String", Symbol("explanation")=>"String", Symbol("matchStatus")=>"String", Symbol("score")=>"Float64", )
OpenAPI.property_type(::Type{ NameMatchedOut }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_NameMatchedOut[name]))}
function check_required(o::NameMatchedOut)
true
end
function OpenAPI.validate_property(::Type{ NameMatchedOut }, name::Symbol, val)
if name === Symbol("matchStatus")
OpenAPI.validate_param(name, "NameMatchedOut", :enum, val, ["Match", "Mismatch"])
end
if name === Symbol("score")
OpenAPI.validate_param(name, "NameMatchedOut", :format, val, "double")
end
end
| NamSor | https://github.com/NeroBlackstone/NamSor.jl.git |
|
[
"MIT"
] | 0.1.0 | 2d6ab091a1f4af72f40a76fe35b2c01982aa0bbf | code | 5020 | # This file was generated by the Julia OpenAPI Code Generator
# Do not modify this file directly. Modify the OpenAPI specification instead.
@doc raw"""PersonalNameCastegroupOut
Caste group-coded names
PersonalNameCastegroupOut(;
script=nothing,
id=nothing,
explanation=nothing,
name=nothing,
score=nothing,
castegroup=nothing,
castegroupAlt=nothing,
castegroupTop=nothing,
probabilityCalibrated=nothing,
probabilityAltCalibrated=nothing,
)
- script::String
- id::String
- explanation::String
- name::String : The input name.
- score::Float64 : Higher score is better, but score is not normalized. Use calibratedProbability if available.
- castegroup::String : Most likely caste group
- castegroupAlt::String : Second best alternative : caste group
- castegroupTop::Vector{String} : List caste group (top 10)
- probabilityCalibrated::Float64 : The calibrated probability for country to have been guessed correctly. -1 = still calibrating.
- probabilityAltCalibrated::Float64 : The calibrated probability for country OR countryAlt to have been guessed correctly. -1 = still calibrating.
"""
Base.@kwdef mutable struct PersonalNameCastegroupOut <: OpenAPI.APIModel
script::Union{Nothing, String} = nothing
id::Union{Nothing, String} = nothing
explanation::Union{Nothing, String} = nothing
name::Union{Nothing, String} = nothing
score::Union{Nothing, Float64} = nothing
castegroup::Union{Nothing, String} = nothing
castegroupAlt::Union{Nothing, String} = nothing
castegroupTop::Union{Nothing, Vector{String}} = nothing
probabilityCalibrated::Union{Nothing, Float64} = nothing
probabilityAltCalibrated::Union{Nothing, Float64} = nothing
function PersonalNameCastegroupOut(script, id, explanation, name, score, castegroup, castegroupAlt, castegroupTop, probabilityCalibrated, probabilityAltCalibrated, )
OpenAPI.validate_property(PersonalNameCastegroupOut, Symbol("script"), script)
OpenAPI.validate_property(PersonalNameCastegroupOut, Symbol("id"), id)
OpenAPI.validate_property(PersonalNameCastegroupOut, Symbol("explanation"), explanation)
OpenAPI.validate_property(PersonalNameCastegroupOut, Symbol("name"), name)
OpenAPI.validate_property(PersonalNameCastegroupOut, Symbol("score"), score)
OpenAPI.validate_property(PersonalNameCastegroupOut, Symbol("castegroup"), castegroup)
OpenAPI.validate_property(PersonalNameCastegroupOut, Symbol("castegroupAlt"), castegroupAlt)
OpenAPI.validate_property(PersonalNameCastegroupOut, Symbol("castegroupTop"), castegroupTop)
OpenAPI.validate_property(PersonalNameCastegroupOut, Symbol("probabilityCalibrated"), probabilityCalibrated)
OpenAPI.validate_property(PersonalNameCastegroupOut, Symbol("probabilityAltCalibrated"), probabilityAltCalibrated)
return new(script, id, explanation, name, score, castegroup, castegroupAlt, castegroupTop, probabilityCalibrated, probabilityAltCalibrated, )
end
end # type PersonalNameCastegroupOut
const _property_types_PersonalNameCastegroupOut = Dict{Symbol,String}(Symbol("script")=>"String", Symbol("id")=>"String", Symbol("explanation")=>"String", Symbol("name")=>"String", Symbol("score")=>"Float64", Symbol("castegroup")=>"String", Symbol("castegroupAlt")=>"String", Symbol("castegroupTop")=>"Vector{String}", Symbol("probabilityCalibrated")=>"Float64", Symbol("probabilityAltCalibrated")=>"Float64", )
OpenAPI.property_type(::Type{ PersonalNameCastegroupOut }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_PersonalNameCastegroupOut[name]))}
function check_required(o::PersonalNameCastegroupOut)
true
end
function OpenAPI.validate_property(::Type{ PersonalNameCastegroupOut }, name::Symbol, val)
if name === Symbol("score")
OpenAPI.validate_param(name, "PersonalNameCastegroupOut", :format, val, "double")
end
if name === Symbol("score")
OpenAPI.validate_param(name, "PersonalNameCastegroupOut", :maximum, val, 100, false)
OpenAPI.validate_param(name, "PersonalNameCastegroupOut", :minimum, val, 0, false)
end
if name === Symbol("probabilityCalibrated")
OpenAPI.validate_param(name, "PersonalNameCastegroupOut", :format, val, "double")
end
if name === Symbol("probabilityCalibrated")
OpenAPI.validate_param(name, "PersonalNameCastegroupOut", :maximum, val, 1, false)
OpenAPI.validate_param(name, "PersonalNameCastegroupOut", :minimum, val, -1, false)
end
if name === Symbol("probabilityAltCalibrated")
OpenAPI.validate_param(name, "PersonalNameCastegroupOut", :format, val, "double")
end
if name === Symbol("probabilityAltCalibrated")
OpenAPI.validate_param(name, "PersonalNameCastegroupOut", :maximum, val, 1, false)
OpenAPI.validate_param(name, "PersonalNameCastegroupOut", :minimum, val, -1, false)
end
end
| NamSor | https://github.com/NeroBlackstone/NamSor.jl.git |
|
[
"MIT"
] | 0.1.0 | 2d6ab091a1f4af72f40a76fe35b2c01982aa0bbf | code | 6834 | # This file was generated by the Julia OpenAPI Code Generator
# Do not modify this file directly. Modify the OpenAPI specification instead.
@doc raw"""PersonalNameDiasporaedOut
Represents the output of inferring the LIKELY ethnicity from a personal name, given an country of residence.
PersonalNameDiasporaedOut(;
script=nothing,
id=nothing,
explanation=nothing,
name=nothing,
score=nothing,
ethnicityAlt=nothing,
ethnicity=nothing,
lifted=nothing,
countryIso2=nothing,
ethnicitiesTop=nothing,
probabilityCalibrated=nothing,
probabilityAltCalibrated=nothing,
religionStats=nothing,
religionStatsAlt=nothing,
)
- script::String
- id::String
- explanation::String
- name::String : The input name.
- score::Float64 : Compatibility to NamSor_v1 Diaspora score value. Higher score is better, but score is not normalized. Use calibratedProbability if available.
- ethnicityAlt::String : The second best alternative ethnicity
- ethnicity::String : The most likely ethnicity
- lifted::Bool : Indicates if the output ethnicity is based on machine learning only, or further lifted as a known fact by a country-specific rule. Let us know if you believe ethnicity is incorrect on a specific case where lifted is true.
- countryIso2::String : From input data, the countryIso2 of geographic context (US,CA etc.)
- ethnicitiesTop::Vector{String} : List most likely ethnicities (top 10)
- probabilityCalibrated::Float64 : The calibrated probability for ethnicity to have been guessed correctly. -1 = still calibrating.
- probabilityAltCalibrated::Float64 : The calibrated probability for ethnicity OR ethnicityAlt to have been guessed correctly. -1 = still calibrating.
- religionStats::Vector{ReligionStatOut} : Geographic religious statistics, assuming ethnicity is correctly predicted.
- religionStatsAlt::Vector{ReligionStatOut} : Geographic religious statistics, for country best alternative.
"""
Base.@kwdef mutable struct PersonalNameDiasporaedOut <: OpenAPI.APIModel
script::Union{Nothing, String} = nothing
id::Union{Nothing, String} = nothing
explanation::Union{Nothing, String} = nothing
name::Union{Nothing, String} = nothing
score::Union{Nothing, Float64} = nothing
ethnicityAlt::Union{Nothing, String} = nothing
ethnicity::Union{Nothing, String} = nothing
lifted::Union{Nothing, Bool} = nothing
countryIso2::Union{Nothing, String} = nothing
ethnicitiesTop::Union{Nothing, Vector{String}} = nothing
probabilityCalibrated::Union{Nothing, Float64} = nothing
probabilityAltCalibrated::Union{Nothing, Float64} = nothing
religionStats::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{ReligionStatOut} }
religionStatsAlt::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{ReligionStatOut} }
function PersonalNameDiasporaedOut(script, id, explanation, name, score, ethnicityAlt, ethnicity, lifted, countryIso2, ethnicitiesTop, probabilityCalibrated, probabilityAltCalibrated, religionStats, religionStatsAlt, )
OpenAPI.validate_property(PersonalNameDiasporaedOut, Symbol("script"), script)
OpenAPI.validate_property(PersonalNameDiasporaedOut, Symbol("id"), id)
OpenAPI.validate_property(PersonalNameDiasporaedOut, Symbol("explanation"), explanation)
OpenAPI.validate_property(PersonalNameDiasporaedOut, Symbol("name"), name)
OpenAPI.validate_property(PersonalNameDiasporaedOut, Symbol("score"), score)
OpenAPI.validate_property(PersonalNameDiasporaedOut, Symbol("ethnicityAlt"), ethnicityAlt)
OpenAPI.validate_property(PersonalNameDiasporaedOut, Symbol("ethnicity"), ethnicity)
OpenAPI.validate_property(PersonalNameDiasporaedOut, Symbol("lifted"), lifted)
OpenAPI.validate_property(PersonalNameDiasporaedOut, Symbol("countryIso2"), countryIso2)
OpenAPI.validate_property(PersonalNameDiasporaedOut, Symbol("ethnicitiesTop"), ethnicitiesTop)
OpenAPI.validate_property(PersonalNameDiasporaedOut, Symbol("probabilityCalibrated"), probabilityCalibrated)
OpenAPI.validate_property(PersonalNameDiasporaedOut, Symbol("probabilityAltCalibrated"), probabilityAltCalibrated)
OpenAPI.validate_property(PersonalNameDiasporaedOut, Symbol("religionStats"), religionStats)
OpenAPI.validate_property(PersonalNameDiasporaedOut, Symbol("religionStatsAlt"), religionStatsAlt)
return new(script, id, explanation, name, score, ethnicityAlt, ethnicity, lifted, countryIso2, ethnicitiesTop, probabilityCalibrated, probabilityAltCalibrated, religionStats, religionStatsAlt, )
end
end # type PersonalNameDiasporaedOut
const _property_types_PersonalNameDiasporaedOut = Dict{Symbol,String}(Symbol("script")=>"String", Symbol("id")=>"String", Symbol("explanation")=>"String", Symbol("name")=>"String", Symbol("score")=>"Float64", Symbol("ethnicityAlt")=>"String", Symbol("ethnicity")=>"String", Symbol("lifted")=>"Bool", Symbol("countryIso2")=>"String", Symbol("ethnicitiesTop")=>"Vector{String}", Symbol("probabilityCalibrated")=>"Float64", Symbol("probabilityAltCalibrated")=>"Float64", Symbol("religionStats")=>"Vector{ReligionStatOut}", Symbol("religionStatsAlt")=>"Vector{ReligionStatOut}", )
OpenAPI.property_type(::Type{ PersonalNameDiasporaedOut }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_PersonalNameDiasporaedOut[name]))}
function check_required(o::PersonalNameDiasporaedOut)
true
end
function OpenAPI.validate_property(::Type{ PersonalNameDiasporaedOut }, name::Symbol, val)
if name === Symbol("score")
OpenAPI.validate_param(name, "PersonalNameDiasporaedOut", :format, val, "double")
end
if name === Symbol("score")
OpenAPI.validate_param(name, "PersonalNameDiasporaedOut", :maximum, val, 100, false)
OpenAPI.validate_param(name, "PersonalNameDiasporaedOut", :minimum, val, 0, false)
end
if name === Symbol("probabilityCalibrated")
OpenAPI.validate_param(name, "PersonalNameDiasporaedOut", :format, val, "double")
end
if name === Symbol("probabilityCalibrated")
OpenAPI.validate_param(name, "PersonalNameDiasporaedOut", :maximum, val, 1, false)
OpenAPI.validate_param(name, "PersonalNameDiasporaedOut", :minimum, val, -1, false)
end
if name === Symbol("probabilityAltCalibrated")
OpenAPI.validate_param(name, "PersonalNameDiasporaedOut", :format, val, "double")
end
if name === Symbol("probabilityAltCalibrated")
OpenAPI.validate_param(name, "PersonalNameDiasporaedOut", :maximum, val, 1, false)
OpenAPI.validate_param(name, "PersonalNameDiasporaedOut", :minimum, val, -1, false)
end
end
| NamSor | https://github.com/NeroBlackstone/NamSor.jl.git |
|
[
"MIT"
] | 0.1.0 | 2d6ab091a1f4af72f40a76fe35b2c01982aa0bbf | code | 4359 | # This file was generated by the Julia OpenAPI Code Generator
# Do not modify this file directly. Modify the OpenAPI specification instead.
@doc raw"""PersonalNameGenderedOut
Classified genderized names
PersonalNameGenderedOut(;
script=nothing,
id=nothing,
explanation=nothing,
name=nothing,
likelyGender=nothing,
genderScale=nothing,
score=nothing,
probabilityCalibrated=nothing,
)
- script::String
- id::String
- explanation::String
- name::String : The input name.
- likelyGender::String : Most likely gender
- genderScale::Float64 : Compatibility to NamSor_v1 Gender Scale M[-1..U..+1]F value.
- score::Float64 : Compatibility to NamSor_v1 Gender score value. Higher score is better, but score is not normalized. Use calibratedProbability if available.
- probabilityCalibrated::Float64 : The calibrated probability for inferred gender to have been guessed correctly. -1 = still calibrating.
"""
Base.@kwdef mutable struct PersonalNameGenderedOut <: OpenAPI.APIModel
script::Union{Nothing, String} = nothing
id::Union{Nothing, String} = nothing
explanation::Union{Nothing, String} = nothing
name::Union{Nothing, String} = nothing
likelyGender::Union{Nothing, String} = nothing
genderScale::Union{Nothing, Float64} = nothing
score::Union{Nothing, Float64} = nothing
probabilityCalibrated::Union{Nothing, Float64} = nothing
function PersonalNameGenderedOut(script, id, explanation, name, likelyGender, genderScale, score, probabilityCalibrated, )
OpenAPI.validate_property(PersonalNameGenderedOut, Symbol("script"), script)
OpenAPI.validate_property(PersonalNameGenderedOut, Symbol("id"), id)
OpenAPI.validate_property(PersonalNameGenderedOut, Symbol("explanation"), explanation)
OpenAPI.validate_property(PersonalNameGenderedOut, Symbol("name"), name)
OpenAPI.validate_property(PersonalNameGenderedOut, Symbol("likelyGender"), likelyGender)
OpenAPI.validate_property(PersonalNameGenderedOut, Symbol("genderScale"), genderScale)
OpenAPI.validate_property(PersonalNameGenderedOut, Symbol("score"), score)
OpenAPI.validate_property(PersonalNameGenderedOut, Symbol("probabilityCalibrated"), probabilityCalibrated)
return new(script, id, explanation, name, likelyGender, genderScale, score, probabilityCalibrated, )
end
end # type PersonalNameGenderedOut
const _property_types_PersonalNameGenderedOut = Dict{Symbol,String}(Symbol("script")=>"String", Symbol("id")=>"String", Symbol("explanation")=>"String", Symbol("name")=>"String", Symbol("likelyGender")=>"String", Symbol("genderScale")=>"Float64", Symbol("score")=>"Float64", Symbol("probabilityCalibrated")=>"Float64", )
OpenAPI.property_type(::Type{ PersonalNameGenderedOut }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_PersonalNameGenderedOut[name]))}
function check_required(o::PersonalNameGenderedOut)
true
end
function OpenAPI.validate_property(::Type{ PersonalNameGenderedOut }, name::Symbol, val)
if name === Symbol("likelyGender")
OpenAPI.validate_param(name, "PersonalNameGenderedOut", :enum, val, ["male", "female", "unknown"])
end
if name === Symbol("genderScale")
OpenAPI.validate_param(name, "PersonalNameGenderedOut", :format, val, "double")
end
if name === Symbol("genderScale")
OpenAPI.validate_param(name, "PersonalNameGenderedOut", :maximum, val, 1, false)
OpenAPI.validate_param(name, "PersonalNameGenderedOut", :minimum, val, -1, false)
end
if name === Symbol("score")
OpenAPI.validate_param(name, "PersonalNameGenderedOut", :format, val, "double")
end
if name === Symbol("score")
OpenAPI.validate_param(name, "PersonalNameGenderedOut", :maximum, val, 100, false)
OpenAPI.validate_param(name, "PersonalNameGenderedOut", :minimum, val, 0, false)
end
if name === Symbol("probabilityCalibrated")
OpenAPI.validate_param(name, "PersonalNameGenderedOut", :format, val, "double")
end
if name === Symbol("probabilityCalibrated")
OpenAPI.validate_param(name, "PersonalNameGenderedOut", :maximum, val, 1, false)
OpenAPI.validate_param(name, "PersonalNameGenderedOut", :minimum, val, -1, false)
end
end
| NamSor | https://github.com/NeroBlackstone/NamSor.jl.git |
|
[
"MIT"
] | 0.1.0 | 2d6ab091a1f4af72f40a76fe35b2c01982aa0bbf | code | 1353 | # This file was generated by the Julia OpenAPI Code Generator
# Do not modify this file directly. Modify the OpenAPI specification instead.
@doc raw"""PersonalNameGeoIn
PersonalNameGeoIn(;
id=nothing,
name=nothing,
countryIso2=nothing,
)
- id::String
- name::String
- countryIso2::String
"""
Base.@kwdef mutable struct PersonalNameGeoIn <: OpenAPI.APIModel
id::Union{Nothing, String} = nothing
name::Union{Nothing, String} = nothing
countryIso2::Union{Nothing, String} = nothing
function PersonalNameGeoIn(id, name, countryIso2, )
OpenAPI.validate_property(PersonalNameGeoIn, Symbol("id"), id)
OpenAPI.validate_property(PersonalNameGeoIn, Symbol("name"), name)
OpenAPI.validate_property(PersonalNameGeoIn, Symbol("countryIso2"), countryIso2)
return new(id, name, countryIso2, )
end
end # type PersonalNameGeoIn
const _property_types_PersonalNameGeoIn = Dict{Symbol,String}(Symbol("id")=>"String", Symbol("name")=>"String", Symbol("countryIso2")=>"String", )
OpenAPI.property_type(::Type{ PersonalNameGeoIn }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_PersonalNameGeoIn[name]))}
function check_required(o::PersonalNameGeoIn)
true
end
function OpenAPI.validate_property(::Type{ PersonalNameGeoIn }, name::Symbol, val)
end
| NamSor | https://github.com/NeroBlackstone/NamSor.jl.git |
|
[
"MIT"
] | 0.1.0 | 2d6ab091a1f4af72f40a76fe35b2c01982aa0bbf | code | 6459 | # This file was generated by the Julia OpenAPI Code Generator
# Do not modify this file directly. Modify the OpenAPI specification instead.
@doc raw"""PersonalNameGeoOut
PersonalNameGeoOut(;
script=nothing,
id=nothing,
explanation=nothing,
name=nothing,
score=nothing,
country=nothing,
countryAlt=nothing,
region=nothing,
topRegion=nothing,
subRegion=nothing,
countriesTop=nothing,
probabilityCalibrated=nothing,
probabilityAltCalibrated=nothing,
religionStats=nothing,
religionStatsAlt=nothing,
)
- script::String
- id::String
- explanation::String
- name::String : The input name.
- score::Float64 : Higher score is better, but score is not normalized. Use calibratedProbability if available.
- country::String : Most likely country
- countryAlt::String : Second best alternative : country
- region::String : Most likely region (based on country ISO2 code)
- topRegion::String : Most likely top region (based on country ISO2 code)
- subRegion::String : Most likely sub region (based on country ISO2 code)
- countriesTop::Vector{String} : List countries (top 10)
- probabilityCalibrated::Float64 : The calibrated probability for country to have been guessed correctly. -1 = still calibrating.
- probabilityAltCalibrated::Float64 : The calibrated probability for country OR countryAlt to have been guessed correctly. -1 = still calibrating.
- religionStats::Vector{ReligionStatOut} : Geographic religious statistics, assuming country is correctly predicted.
- religionStatsAlt::Vector{ReligionStatOut} : Geographic religious statistics, for country best alternative.
"""
Base.@kwdef mutable struct PersonalNameGeoOut <: OpenAPI.APIModel
script::Union{Nothing, String} = nothing
id::Union{Nothing, String} = nothing
explanation::Union{Nothing, String} = nothing
name::Union{Nothing, String} = nothing
score::Union{Nothing, Float64} = nothing
country::Union{Nothing, String} = nothing
countryAlt::Union{Nothing, String} = nothing
region::Union{Nothing, String} = nothing
topRegion::Union{Nothing, String} = nothing
subRegion::Union{Nothing, String} = nothing
countriesTop::Union{Nothing, Vector{String}} = nothing
probabilityCalibrated::Union{Nothing, Float64} = nothing
probabilityAltCalibrated::Union{Nothing, Float64} = nothing
religionStats::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{ReligionStatOut} }
religionStatsAlt::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{ReligionStatOut} }
function PersonalNameGeoOut(script, id, explanation, name, score, country, countryAlt, region, topRegion, subRegion, countriesTop, probabilityCalibrated, probabilityAltCalibrated, religionStats, religionStatsAlt, )
OpenAPI.validate_property(PersonalNameGeoOut, Symbol("script"), script)
OpenAPI.validate_property(PersonalNameGeoOut, Symbol("id"), id)
OpenAPI.validate_property(PersonalNameGeoOut, Symbol("explanation"), explanation)
OpenAPI.validate_property(PersonalNameGeoOut, Symbol("name"), name)
OpenAPI.validate_property(PersonalNameGeoOut, Symbol("score"), score)
OpenAPI.validate_property(PersonalNameGeoOut, Symbol("country"), country)
OpenAPI.validate_property(PersonalNameGeoOut, Symbol("countryAlt"), countryAlt)
OpenAPI.validate_property(PersonalNameGeoOut, Symbol("region"), region)
OpenAPI.validate_property(PersonalNameGeoOut, Symbol("topRegion"), topRegion)
OpenAPI.validate_property(PersonalNameGeoOut, Symbol("subRegion"), subRegion)
OpenAPI.validate_property(PersonalNameGeoOut, Symbol("countriesTop"), countriesTop)
OpenAPI.validate_property(PersonalNameGeoOut, Symbol("probabilityCalibrated"), probabilityCalibrated)
OpenAPI.validate_property(PersonalNameGeoOut, Symbol("probabilityAltCalibrated"), probabilityAltCalibrated)
OpenAPI.validate_property(PersonalNameGeoOut, Symbol("religionStats"), religionStats)
OpenAPI.validate_property(PersonalNameGeoOut, Symbol("religionStatsAlt"), religionStatsAlt)
return new(script, id, explanation, name, score, country, countryAlt, region, topRegion, subRegion, countriesTop, probabilityCalibrated, probabilityAltCalibrated, religionStats, religionStatsAlt, )
end
end # type PersonalNameGeoOut
const _property_types_PersonalNameGeoOut = Dict{Symbol,String}(Symbol("script")=>"String", Symbol("id")=>"String", Symbol("explanation")=>"String", Symbol("name")=>"String", Symbol("score")=>"Float64", Symbol("country")=>"String", Symbol("countryAlt")=>"String", Symbol("region")=>"String", Symbol("topRegion")=>"String", Symbol("subRegion")=>"String", Symbol("countriesTop")=>"Vector{String}", Symbol("probabilityCalibrated")=>"Float64", Symbol("probabilityAltCalibrated")=>"Float64", Symbol("religionStats")=>"Vector{ReligionStatOut}", Symbol("religionStatsAlt")=>"Vector{ReligionStatOut}", )
OpenAPI.property_type(::Type{ PersonalNameGeoOut }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_PersonalNameGeoOut[name]))}
function check_required(o::PersonalNameGeoOut)
true
end
function OpenAPI.validate_property(::Type{ PersonalNameGeoOut }, name::Symbol, val)
if name === Symbol("score")
OpenAPI.validate_param(name, "PersonalNameGeoOut", :format, val, "double")
end
if name === Symbol("score")
OpenAPI.validate_param(name, "PersonalNameGeoOut", :maximum, val, 100, false)
OpenAPI.validate_param(name, "PersonalNameGeoOut", :minimum, val, 0, false)
end
if name === Symbol("probabilityCalibrated")
OpenAPI.validate_param(name, "PersonalNameGeoOut", :format, val, "double")
end
if name === Symbol("probabilityCalibrated")
OpenAPI.validate_param(name, "PersonalNameGeoOut", :maximum, val, 1, false)
OpenAPI.validate_param(name, "PersonalNameGeoOut", :minimum, val, -1, false)
end
if name === Symbol("probabilityAltCalibrated")
OpenAPI.validate_param(name, "PersonalNameGeoOut", :format, val, "double")
end
if name === Symbol("probabilityAltCalibrated")
OpenAPI.validate_param(name, "PersonalNameGeoOut", :maximum, val, 1, false)
OpenAPI.validate_param(name, "PersonalNameGeoOut", :minimum, val, -1, false)
end
end
| NamSor | https://github.com/NeroBlackstone/NamSor.jl.git |
|
[
"MIT"
] | 0.1.0 | 2d6ab091a1f4af72f40a76fe35b2c01982aa0bbf | code | 5954 | # This file was generated by the Julia OpenAPI Code Generator
# Do not modify this file directly. Modify the OpenAPI specification instead.
@doc raw"""PersonalNameGeoSubclassificationOut
Classified names at sub country level (region or state)
PersonalNameGeoSubclassificationOut(;
script=nothing,
id=nothing,
explanation=nothing,
name=nothing,
countryIso2=nothing,
subClassification=nothing,
subClassificationAlt=nothing,
subclassificationTop=nothing,
score=nothing,
probabilityCalibrated=nothing,
probabilityAltCalibrated=nothing,
)
- script::String
- id::String
- explanation::String
- name::String : The input name.
- countryIso2::String : The input country ISO2 code
- subClassification::String : Most likely subclassification ISO_3166-2 code
- subClassificationAlt::String : Second best alternative : subclassification ISO_3166-2 code
- subclassificationTop::Vector{String} : List subclassification ISO_3166-2 codes (top 10)
- score::Float64 : Compatibility to NamSor_v1 Origin score value. Higher score is better, but score is not normalized. Use calibratedProbability if available.
- probabilityCalibrated::Float64 : The calibrated probability for subclassification to have been guessed correctly. -1 = still calibrating.
- probabilityAltCalibrated::Float64 : The calibrated probability for subclassification OR subclassificationAlt to have been guessed correctly. -1 = still calibrating.
"""
Base.@kwdef mutable struct PersonalNameGeoSubclassificationOut <: OpenAPI.APIModel
script::Union{Nothing, String} = nothing
id::Union{Nothing, String} = nothing
explanation::Union{Nothing, String} = nothing
name::Union{Nothing, String} = nothing
countryIso2::Union{Nothing, String} = nothing
subClassification::Union{Nothing, String} = nothing
subClassificationAlt::Union{Nothing, String} = nothing
subclassificationTop::Union{Nothing, Vector{String}} = nothing
score::Union{Nothing, Float64} = nothing
probabilityCalibrated::Union{Nothing, Float64} = nothing
probabilityAltCalibrated::Union{Nothing, Float64} = nothing
function PersonalNameGeoSubclassificationOut(script, id, explanation, name, countryIso2, subClassification, subClassificationAlt, subclassificationTop, score, probabilityCalibrated, probabilityAltCalibrated, )
OpenAPI.validate_property(PersonalNameGeoSubclassificationOut, Symbol("script"), script)
OpenAPI.validate_property(PersonalNameGeoSubclassificationOut, Symbol("id"), id)
OpenAPI.validate_property(PersonalNameGeoSubclassificationOut, Symbol("explanation"), explanation)
OpenAPI.validate_property(PersonalNameGeoSubclassificationOut, Symbol("name"), name)
OpenAPI.validate_property(PersonalNameGeoSubclassificationOut, Symbol("countryIso2"), countryIso2)
OpenAPI.validate_property(PersonalNameGeoSubclassificationOut, Symbol("subClassification"), subClassification)
OpenAPI.validate_property(PersonalNameGeoSubclassificationOut, Symbol("subClassificationAlt"), subClassificationAlt)
OpenAPI.validate_property(PersonalNameGeoSubclassificationOut, Symbol("subclassificationTop"), subclassificationTop)
OpenAPI.validate_property(PersonalNameGeoSubclassificationOut, Symbol("score"), score)
OpenAPI.validate_property(PersonalNameGeoSubclassificationOut, Symbol("probabilityCalibrated"), probabilityCalibrated)
OpenAPI.validate_property(PersonalNameGeoSubclassificationOut, Symbol("probabilityAltCalibrated"), probabilityAltCalibrated)
return new(script, id, explanation, name, countryIso2, subClassification, subClassificationAlt, subclassificationTop, score, probabilityCalibrated, probabilityAltCalibrated, )
end
end # type PersonalNameGeoSubclassificationOut
const _property_types_PersonalNameGeoSubclassificationOut = Dict{Symbol,String}(Symbol("script")=>"String", Symbol("id")=>"String", Symbol("explanation")=>"String", Symbol("name")=>"String", Symbol("countryIso2")=>"String", Symbol("subClassification")=>"String", Symbol("subClassificationAlt")=>"String", Symbol("subclassificationTop")=>"Vector{String}", Symbol("score")=>"Float64", Symbol("probabilityCalibrated")=>"Float64", Symbol("probabilityAltCalibrated")=>"Float64", )
OpenAPI.property_type(::Type{ PersonalNameGeoSubclassificationOut }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_PersonalNameGeoSubclassificationOut[name]))}
function check_required(o::PersonalNameGeoSubclassificationOut)
true
end
function OpenAPI.validate_property(::Type{ PersonalNameGeoSubclassificationOut }, name::Symbol, val)
if name === Symbol("score")
OpenAPI.validate_param(name, "PersonalNameGeoSubclassificationOut", :format, val, "double")
end
if name === Symbol("score")
OpenAPI.validate_param(name, "PersonalNameGeoSubclassificationOut", :maximum, val, 100, false)
OpenAPI.validate_param(name, "PersonalNameGeoSubclassificationOut", :minimum, val, 0, false)
end
if name === Symbol("probabilityCalibrated")
OpenAPI.validate_param(name, "PersonalNameGeoSubclassificationOut", :format, val, "double")
end
if name === Symbol("probabilityCalibrated")
OpenAPI.validate_param(name, "PersonalNameGeoSubclassificationOut", :maximum, val, 1, false)
OpenAPI.validate_param(name, "PersonalNameGeoSubclassificationOut", :minimum, val, -1, false)
end
if name === Symbol("probabilityAltCalibrated")
OpenAPI.validate_param(name, "PersonalNameGeoSubclassificationOut", :format, val, "double")
end
if name === Symbol("probabilityAltCalibrated")
OpenAPI.validate_param(name, "PersonalNameGeoSubclassificationOut", :maximum, val, 1, false)
OpenAPI.validate_param(name, "PersonalNameGeoSubclassificationOut", :minimum, val, -1, false)
end
end
| NamSor | https://github.com/NeroBlackstone/NamSor.jl.git |
|
[
"MIT"
] | 0.1.0 | 2d6ab091a1f4af72f40a76fe35b2c01982aa0bbf | code | 1784 | # This file was generated by the Julia OpenAPI Code Generator
# Do not modify this file directly. Modify the OpenAPI specification instead.
@doc raw"""PersonalNameGeoSubdivisionIn
PersonalNameGeoSubdivisionIn(;
id=nothing,
name=nothing,
countryIso2=nothing,
subdivisionIso=nothing,
)
- id::String
- name::String
- countryIso2::String
- subdivisionIso::String
"""
Base.@kwdef mutable struct PersonalNameGeoSubdivisionIn <: OpenAPI.APIModel
id::Union{Nothing, String} = nothing
name::Union{Nothing, String} = nothing
countryIso2::Union{Nothing, String} = nothing
subdivisionIso::Union{Nothing, String} = nothing
function PersonalNameGeoSubdivisionIn(id, name, countryIso2, subdivisionIso, )
OpenAPI.validate_property(PersonalNameGeoSubdivisionIn, Symbol("id"), id)
OpenAPI.validate_property(PersonalNameGeoSubdivisionIn, Symbol("name"), name)
OpenAPI.validate_property(PersonalNameGeoSubdivisionIn, Symbol("countryIso2"), countryIso2)
OpenAPI.validate_property(PersonalNameGeoSubdivisionIn, Symbol("subdivisionIso"), subdivisionIso)
return new(id, name, countryIso2, subdivisionIso, )
end
end # type PersonalNameGeoSubdivisionIn
const _property_types_PersonalNameGeoSubdivisionIn = Dict{Symbol,String}(Symbol("id")=>"String", Symbol("name")=>"String", Symbol("countryIso2")=>"String", Symbol("subdivisionIso")=>"String", )
OpenAPI.property_type(::Type{ PersonalNameGeoSubdivisionIn }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_PersonalNameGeoSubdivisionIn[name]))}
function check_required(o::PersonalNameGeoSubdivisionIn)
true
end
function OpenAPI.validate_property(::Type{ PersonalNameGeoSubdivisionIn }, name::Symbol, val)
end
| NamSor | https://github.com/NeroBlackstone/NamSor.jl.git |
|
[
"MIT"
] | 0.1.0 | 2d6ab091a1f4af72f40a76fe35b2c01982aa0bbf | code | 1064 | # This file was generated by the Julia OpenAPI Code Generator
# Do not modify this file directly. Modify the OpenAPI specification instead.
@doc raw"""PersonalNameIn
PersonalNameIn(;
id=nothing,
name=nothing,
)
- id::String
- name::String
"""
Base.@kwdef mutable struct PersonalNameIn <: OpenAPI.APIModel
id::Union{Nothing, String} = nothing
name::Union{Nothing, String} = nothing
function PersonalNameIn(id, name, )
OpenAPI.validate_property(PersonalNameIn, Symbol("id"), id)
OpenAPI.validate_property(PersonalNameIn, Symbol("name"), name)
return new(id, name, )
end
end # type PersonalNameIn
const _property_types_PersonalNameIn = Dict{Symbol,String}(Symbol("id")=>"String", Symbol("name")=>"String", )
OpenAPI.property_type(::Type{ PersonalNameIn }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_PersonalNameIn[name]))}
function check_required(o::PersonalNameIn)
true
end
function OpenAPI.validate_property(::Type{ PersonalNameIn }, name::Symbol, val)
end
| NamSor | https://github.com/NeroBlackstone/NamSor.jl.git |
|
[
"MIT"
] | 0.1.0 | 2d6ab091a1f4af72f40a76fe35b2c01982aa0bbf | code | 7696 | # This file was generated by the Julia OpenAPI Code Generator
# Do not modify this file directly. Modify the OpenAPI specification instead.
@doc raw"""PersonalNameOriginedOut
Represents the output of inferring the LIKELY country of Origin from a personal name.
PersonalNameOriginedOut(;
script=nothing,
id=nothing,
explanation=nothing,
name=nothing,
countryOrigin=nothing,
countryOriginAlt=nothing,
countriesOriginTop=nothing,
score=nothing,
regionOrigin=nothing,
topRegionOrigin=nothing,
subRegionOrigin=nothing,
probabilityCalibrated=nothing,
probabilityAltCalibrated=nothing,
religionStats=nothing,
religionStatsAlt=nothing,
religionStatsSynthetic=nothing,
)
- script::String
- id::String
- explanation::String
- name::String : The input name.
- countryOrigin::String : Most likely country of Origin
- countryOriginAlt::String : Second best alternative : country of Origin
- countriesOriginTop::Vector{String} : List countries of Origin (top 10)
- score::Float64 : Compatibility to NamSor_v1 Origin score value. Higher score is better, but score is not normalized. Use calibratedProbability if available.
- regionOrigin::String : Most likely region of Origin (based on countryOrigin ISO2 code)
- topRegionOrigin::String : Most likely top region of Origin (based on countryOrigin ISO2 code)
- subRegionOrigin::String : Most likely sub region of Origin (based on countryOrigin ISO2 code)
- probabilityCalibrated::Float64 : The calibrated probability for countryOrigin to have been guessed correctly. -1 = still calibrating.
- probabilityAltCalibrated::Float64 : The calibrated probability for countryOrigin OR countryOriginAlt to have been guessed correctly. -1 = still calibrating.
- religionStats::Vector{ReligionStatOut} : Geographic religious statistics, assuming country of origin is correctly predicted.
- religionStatsAlt::Vector{ReligionStatOut} : Geographic religious statistics, for country best alternative.
- religionStatsSynthetic::Vector{ReligionStatOut} : Geographic religious statistics, assuming country of origin OR best alternative is correctly predicted.
"""
Base.@kwdef mutable struct PersonalNameOriginedOut <: OpenAPI.APIModel
script::Union{Nothing, String} = nothing
id::Union{Nothing, String} = nothing
explanation::Union{Nothing, String} = nothing
name::Union{Nothing, String} = nothing
countryOrigin::Union{Nothing, String} = nothing
countryOriginAlt::Union{Nothing, String} = nothing
countriesOriginTop::Union{Nothing, Vector{String}} = nothing
score::Union{Nothing, Float64} = nothing
regionOrigin::Union{Nothing, String} = nothing
topRegionOrigin::Union{Nothing, String} = nothing
subRegionOrigin::Union{Nothing, String} = nothing
probabilityCalibrated::Union{Nothing, Float64} = nothing
probabilityAltCalibrated::Union{Nothing, Float64} = nothing
religionStats::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{ReligionStatOut} }
religionStatsAlt::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{ReligionStatOut} }
religionStatsSynthetic::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{ReligionStatOut} }
function PersonalNameOriginedOut(script, id, explanation, name, countryOrigin, countryOriginAlt, countriesOriginTop, score, regionOrigin, topRegionOrigin, subRegionOrigin, probabilityCalibrated, probabilityAltCalibrated, religionStats, religionStatsAlt, religionStatsSynthetic, )
OpenAPI.validate_property(PersonalNameOriginedOut, Symbol("script"), script)
OpenAPI.validate_property(PersonalNameOriginedOut, Symbol("id"), id)
OpenAPI.validate_property(PersonalNameOriginedOut, Symbol("explanation"), explanation)
OpenAPI.validate_property(PersonalNameOriginedOut, Symbol("name"), name)
OpenAPI.validate_property(PersonalNameOriginedOut, Symbol("countryOrigin"), countryOrigin)
OpenAPI.validate_property(PersonalNameOriginedOut, Symbol("countryOriginAlt"), countryOriginAlt)
OpenAPI.validate_property(PersonalNameOriginedOut, Symbol("countriesOriginTop"), countriesOriginTop)
OpenAPI.validate_property(PersonalNameOriginedOut, Symbol("score"), score)
OpenAPI.validate_property(PersonalNameOriginedOut, Symbol("regionOrigin"), regionOrigin)
OpenAPI.validate_property(PersonalNameOriginedOut, Symbol("topRegionOrigin"), topRegionOrigin)
OpenAPI.validate_property(PersonalNameOriginedOut, Symbol("subRegionOrigin"), subRegionOrigin)
OpenAPI.validate_property(PersonalNameOriginedOut, Symbol("probabilityCalibrated"), probabilityCalibrated)
OpenAPI.validate_property(PersonalNameOriginedOut, Symbol("probabilityAltCalibrated"), probabilityAltCalibrated)
OpenAPI.validate_property(PersonalNameOriginedOut, Symbol("religionStats"), religionStats)
OpenAPI.validate_property(PersonalNameOriginedOut, Symbol("religionStatsAlt"), religionStatsAlt)
OpenAPI.validate_property(PersonalNameOriginedOut, Symbol("religionStatsSynthetic"), religionStatsSynthetic)
return new(script, id, explanation, name, countryOrigin, countryOriginAlt, countriesOriginTop, score, regionOrigin, topRegionOrigin, subRegionOrigin, probabilityCalibrated, probabilityAltCalibrated, religionStats, religionStatsAlt, religionStatsSynthetic, )
end
end # type PersonalNameOriginedOut
const _property_types_PersonalNameOriginedOut = Dict{Symbol,String}(Symbol("script")=>"String", Symbol("id")=>"String", Symbol("explanation")=>"String", Symbol("name")=>"String", Symbol("countryOrigin")=>"String", Symbol("countryOriginAlt")=>"String", Symbol("countriesOriginTop")=>"Vector{String}", Symbol("score")=>"Float64", Symbol("regionOrigin")=>"String", Symbol("topRegionOrigin")=>"String", Symbol("subRegionOrigin")=>"String", Symbol("probabilityCalibrated")=>"Float64", Symbol("probabilityAltCalibrated")=>"Float64", Symbol("religionStats")=>"Vector{ReligionStatOut}", Symbol("religionStatsAlt")=>"Vector{ReligionStatOut}", Symbol("religionStatsSynthetic")=>"Vector{ReligionStatOut}", )
OpenAPI.property_type(::Type{ PersonalNameOriginedOut }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_PersonalNameOriginedOut[name]))}
function check_required(o::PersonalNameOriginedOut)
true
end
function OpenAPI.validate_property(::Type{ PersonalNameOriginedOut }, name::Symbol, val)
if name === Symbol("score")
OpenAPI.validate_param(name, "PersonalNameOriginedOut", :format, val, "double")
end
if name === Symbol("score")
OpenAPI.validate_param(name, "PersonalNameOriginedOut", :maximum, val, 100, false)
OpenAPI.validate_param(name, "PersonalNameOriginedOut", :minimum, val, 0, false)
end
if name === Symbol("probabilityCalibrated")
OpenAPI.validate_param(name, "PersonalNameOriginedOut", :format, val, "double")
end
if name === Symbol("probabilityCalibrated")
OpenAPI.validate_param(name, "PersonalNameOriginedOut", :maximum, val, 1, false)
OpenAPI.validate_param(name, "PersonalNameOriginedOut", :minimum, val, -1, false)
end
if name === Symbol("probabilityAltCalibrated")
OpenAPI.validate_param(name, "PersonalNameOriginedOut", :format, val, "double")
end
if name === Symbol("probabilityAltCalibrated")
OpenAPI.validate_param(name, "PersonalNameOriginedOut", :maximum, val, 1, false)
OpenAPI.validate_param(name, "PersonalNameOriginedOut", :minimum, val, -1, false)
end
end
| NamSor | https://github.com/NeroBlackstone/NamSor.jl.git |
|
[
"MIT"
] | 0.1.0 | 2d6ab091a1f4af72f40a76fe35b2c01982aa0bbf | code | 4063 | # This file was generated by the Julia OpenAPI Code Generator
# Do not modify this file directly. Modify the OpenAPI specification instead.
@doc raw"""PersonalNameParsedOut
PersonalNameParsedOut(;
script=nothing,
id=nothing,
explanation=nothing,
name=nothing,
nameParserType=nothing,
nameParserTypeAlt=nothing,
firstLastName=nothing,
score=nothing,
)
- script::String
- id::String
- explanation::String
- name::String : The input name.
- nameParserType::String : Name parsing is addressed as a classification problem, for example FN1LN1 means a first then last name order.
- nameParserTypeAlt::String : Second best alternative parsing. Name parsing is addressed as a classification problem, for example FN1LN1 means a first then last name order.
- firstLastName::FirstLastNameOut
- score::Float64 : Higher score is better, but score is not normalized. Use calibratedProbability if available.
"""
Base.@kwdef mutable struct PersonalNameParsedOut <: OpenAPI.APIModel
script::Union{Nothing, String} = nothing
id::Union{Nothing, String} = nothing
explanation::Union{Nothing, String} = nothing
name::Union{Nothing, String} = nothing
nameParserType::Union{Nothing, String} = nothing
nameParserTypeAlt::Union{Nothing, String} = nothing
firstLastName = nothing # spec type: Union{ Nothing, FirstLastNameOut }
score::Union{Nothing, Float64} = nothing
function PersonalNameParsedOut(script, id, explanation, name, nameParserType, nameParserTypeAlt, firstLastName, score, )
OpenAPI.validate_property(PersonalNameParsedOut, Symbol("script"), script)
OpenAPI.validate_property(PersonalNameParsedOut, Symbol("id"), id)
OpenAPI.validate_property(PersonalNameParsedOut, Symbol("explanation"), explanation)
OpenAPI.validate_property(PersonalNameParsedOut, Symbol("name"), name)
OpenAPI.validate_property(PersonalNameParsedOut, Symbol("nameParserType"), nameParserType)
OpenAPI.validate_property(PersonalNameParsedOut, Symbol("nameParserTypeAlt"), nameParserTypeAlt)
OpenAPI.validate_property(PersonalNameParsedOut, Symbol("firstLastName"), firstLastName)
OpenAPI.validate_property(PersonalNameParsedOut, Symbol("score"), score)
return new(script, id, explanation, name, nameParserType, nameParserTypeAlt, firstLastName, score, )
end
end # type PersonalNameParsedOut
const _property_types_PersonalNameParsedOut = Dict{Symbol,String}(Symbol("script")=>"String", Symbol("id")=>"String", Symbol("explanation")=>"String", Symbol("name")=>"String", Symbol("nameParserType")=>"String", Symbol("nameParserTypeAlt")=>"String", Symbol("firstLastName")=>"FirstLastNameOut", Symbol("score")=>"Float64", )
OpenAPI.property_type(::Type{ PersonalNameParsedOut }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_PersonalNameParsedOut[name]))}
function check_required(o::PersonalNameParsedOut)
true
end
function OpenAPI.validate_property(::Type{ PersonalNameParsedOut }, name::Symbol, val)
if name === Symbol("nameParserType")
OpenAPI.validate_param(name, "PersonalNameParsedOut", :enum, val, ["FN1LN1", "LN1FN1", "FN1LN2", "LN2FN1", "FN1LNx", "LNxFN1", "FN2LN1", "LN1FN2", "FN2LN2", "LN2FN2", "FN2LNx", "LNxFN2", "FNxLN1", "LN1FNx", "FNxLN2", "LN2FNx", "FNxLNx", "LNxFNx"])
end
if name === Symbol("nameParserTypeAlt")
OpenAPI.validate_param(name, "PersonalNameParsedOut", :enum, val, ["FN1LN1", "LN1FN1", "FN1LN2", "LN2FN1", "FN1LNx", "LNxFN1", "FN2LN1", "LN1FN2", "FN2LN2", "LN2FN2", "FN2LNx", "LNxFN2", "FNxLN1", "LN1FNx", "FNxLN2", "LN2FNx", "FNxLNx", "LNxFNx"])
end
if name === Symbol("score")
OpenAPI.validate_param(name, "PersonalNameParsedOut", :format, val, "double")
end
if name === Symbol("score")
OpenAPI.validate_param(name, "PersonalNameParsedOut", :maximum, val, 100, false)
OpenAPI.validate_param(name, "PersonalNameParsedOut", :minimum, val, 0, false)
end
end
| NamSor | https://github.com/NeroBlackstone/NamSor.jl.git |
|
[
"MIT"
] | 0.1.0 | 2d6ab091a1f4af72f40a76fe35b2c01982aa0bbf | code | 4970 | # This file was generated by the Julia OpenAPI Code Generator
# Do not modify this file directly. Modify the OpenAPI specification instead.
@doc raw"""PersonalNameReligionedOut
religious-coded names
PersonalNameReligionedOut(;
script=nothing,
id=nothing,
explanation=nothing,
name=nothing,
score=nothing,
religion=nothing,
religionAlt=nothing,
religionsTop=nothing,
probabilityCalibrated=nothing,
probabilityAltCalibrated=nothing,
)
- script::String
- id::String
- explanation::String
- name::String : The input name.
- score::Float64 : Higher score is better, but score is not normalized. Use calibratedProbability if available.
- religion::String : Most likely religion
- religionAlt::String : Second best alternative : religion
- religionsTop::Vector{String} : List religions (top 10)
- probabilityCalibrated::Float64 : The calibrated probability for country to have been guessed correctly. -1 = still calibrating.
- probabilityAltCalibrated::Float64 : The calibrated probability for country OR countryAlt to have been guessed correctly. -1 = still calibrating.
"""
Base.@kwdef mutable struct PersonalNameReligionedOut <: OpenAPI.APIModel
script::Union{Nothing, String} = nothing
id::Union{Nothing, String} = nothing
explanation::Union{Nothing, String} = nothing
name::Union{Nothing, String} = nothing
score::Union{Nothing, Float64} = nothing
religion::Union{Nothing, String} = nothing
religionAlt::Union{Nothing, String} = nothing
religionsTop::Union{Nothing, Vector{String}} = nothing
probabilityCalibrated::Union{Nothing, Float64} = nothing
probabilityAltCalibrated::Union{Nothing, Float64} = nothing
function PersonalNameReligionedOut(script, id, explanation, name, score, religion, religionAlt, religionsTop, probabilityCalibrated, probabilityAltCalibrated, )
OpenAPI.validate_property(PersonalNameReligionedOut, Symbol("script"), script)
OpenAPI.validate_property(PersonalNameReligionedOut, Symbol("id"), id)
OpenAPI.validate_property(PersonalNameReligionedOut, Symbol("explanation"), explanation)
OpenAPI.validate_property(PersonalNameReligionedOut, Symbol("name"), name)
OpenAPI.validate_property(PersonalNameReligionedOut, Symbol("score"), score)
OpenAPI.validate_property(PersonalNameReligionedOut, Symbol("religion"), religion)
OpenAPI.validate_property(PersonalNameReligionedOut, Symbol("religionAlt"), religionAlt)
OpenAPI.validate_property(PersonalNameReligionedOut, Symbol("religionsTop"), religionsTop)
OpenAPI.validate_property(PersonalNameReligionedOut, Symbol("probabilityCalibrated"), probabilityCalibrated)
OpenAPI.validate_property(PersonalNameReligionedOut, Symbol("probabilityAltCalibrated"), probabilityAltCalibrated)
return new(script, id, explanation, name, score, religion, religionAlt, religionsTop, probabilityCalibrated, probabilityAltCalibrated, )
end
end # type PersonalNameReligionedOut
const _property_types_PersonalNameReligionedOut = Dict{Symbol,String}(Symbol("script")=>"String", Symbol("id")=>"String", Symbol("explanation")=>"String", Symbol("name")=>"String", Symbol("score")=>"Float64", Symbol("religion")=>"String", Symbol("religionAlt")=>"String", Symbol("religionsTop")=>"Vector{String}", Symbol("probabilityCalibrated")=>"Float64", Symbol("probabilityAltCalibrated")=>"Float64", )
OpenAPI.property_type(::Type{ PersonalNameReligionedOut }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_PersonalNameReligionedOut[name]))}
function check_required(o::PersonalNameReligionedOut)
true
end
function OpenAPI.validate_property(::Type{ PersonalNameReligionedOut }, name::Symbol, val)
if name === Symbol("score")
OpenAPI.validate_param(name, "PersonalNameReligionedOut", :format, val, "double")
end
if name === Symbol("score")
OpenAPI.validate_param(name, "PersonalNameReligionedOut", :maximum, val, 100, false)
OpenAPI.validate_param(name, "PersonalNameReligionedOut", :minimum, val, 0, false)
end
if name === Symbol("probabilityCalibrated")
OpenAPI.validate_param(name, "PersonalNameReligionedOut", :format, val, "double")
end
if name === Symbol("probabilityCalibrated")
OpenAPI.validate_param(name, "PersonalNameReligionedOut", :maximum, val, 1, false)
OpenAPI.validate_param(name, "PersonalNameReligionedOut", :minimum, val, -1, false)
end
if name === Symbol("probabilityAltCalibrated")
OpenAPI.validate_param(name, "PersonalNameReligionedOut", :format, val, "double")
end
if name === Symbol("probabilityAltCalibrated")
OpenAPI.validate_param(name, "PersonalNameReligionedOut", :maximum, val, 1, false)
OpenAPI.validate_param(name, "PersonalNameReligionedOut", :minimum, val, -1, false)
end
end
| NamSor | https://github.com/NeroBlackstone/NamSor.jl.git |
|
[
"MIT"
] | 0.1.0 | 2d6ab091a1f4af72f40a76fe35b2c01982aa0bbf | code | 1481 | # This file was generated by the Julia OpenAPI Code Generator
# Do not modify this file directly. Modify the OpenAPI specification instead.
@doc raw"""PersonalNameSubdivisionIn
PersonalNameSubdivisionIn(;
id=nothing,
name=nothing,
subdivisionIso=nothing,
)
- id::String
- name::String
- subdivisionIso::String
"""
Base.@kwdef mutable struct PersonalNameSubdivisionIn <: OpenAPI.APIModel
id::Union{Nothing, String} = nothing
name::Union{Nothing, String} = nothing
subdivisionIso::Union{Nothing, String} = nothing
function PersonalNameSubdivisionIn(id, name, subdivisionIso, )
OpenAPI.validate_property(PersonalNameSubdivisionIn, Symbol("id"), id)
OpenAPI.validate_property(PersonalNameSubdivisionIn, Symbol("name"), name)
OpenAPI.validate_property(PersonalNameSubdivisionIn, Symbol("subdivisionIso"), subdivisionIso)
return new(id, name, subdivisionIso, )
end
end # type PersonalNameSubdivisionIn
const _property_types_PersonalNameSubdivisionIn = Dict{Symbol,String}(Symbol("id")=>"String", Symbol("name")=>"String", Symbol("subdivisionIso")=>"String", )
OpenAPI.property_type(::Type{ PersonalNameSubdivisionIn }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_PersonalNameSubdivisionIn[name]))}
function check_required(o::PersonalNameSubdivisionIn)
true
end
function OpenAPI.validate_property(::Type{ PersonalNameSubdivisionIn }, name::Symbol, val)
end
| NamSor | https://github.com/NeroBlackstone/NamSor.jl.git |
|
[
"MIT"
] | 0.1.0 | 2d6ab091a1f4af72f40a76fe35b2c01982aa0bbf | code | 5786 | # This file was generated by the Julia OpenAPI Code Generator
# Do not modify this file directly. Modify the OpenAPI specification instead.
@doc raw"""PersonalNameUSRaceEthnicityOut
Represents the output of inferring the LIKELY US 'race/ethnicity' from a personal name, given US country of residence and (optionally) a ZIP5 code.
PersonalNameUSRaceEthnicityOut(;
script=nothing,
id=nothing,
explanation=nothing,
name=nothing,
raceEthnicityAlt=nothing,
raceEthnicity=nothing,
score=nothing,
raceEthnicitiesTop=nothing,
probabilityCalibrated=nothing,
probabilityAltCalibrated=nothing,
)
- script::String
- id::String
- explanation::String
- name::String : The input name.
- raceEthnicityAlt::String : Second most likely US 'race'/ethnicity
- raceEthnicity::String : Most likely US 'race'/ethnicity
- score::Float64 : Higher score is better, but score is not normalized. Use calibratedProbability if available.
- raceEthnicitiesTop::Vector{String} : List 'race'/ethnicities
- probabilityCalibrated::Float64 : The calibrated probability for raceEthnicity to have been guessed correctly. -1 = still calibrating.
- probabilityAltCalibrated::Float64 : The calibrated probability for raceEthnicity OR raceEthnicityAlt to have been guessed correctly. -1 = still calibrating.
"""
Base.@kwdef mutable struct PersonalNameUSRaceEthnicityOut <: OpenAPI.APIModel
script::Union{Nothing, String} = nothing
id::Union{Nothing, String} = nothing
explanation::Union{Nothing, String} = nothing
name::Union{Nothing, String} = nothing
raceEthnicityAlt::Union{Nothing, String} = nothing
raceEthnicity::Union{Nothing, String} = nothing
score::Union{Nothing, Float64} = nothing
raceEthnicitiesTop::Union{Nothing, Vector{String}} = nothing
probabilityCalibrated::Union{Nothing, Float64} = nothing
probabilityAltCalibrated::Union{Nothing, Float64} = nothing
function PersonalNameUSRaceEthnicityOut(script, id, explanation, name, raceEthnicityAlt, raceEthnicity, score, raceEthnicitiesTop, probabilityCalibrated, probabilityAltCalibrated, )
OpenAPI.validate_property(PersonalNameUSRaceEthnicityOut, Symbol("script"), script)
OpenAPI.validate_property(PersonalNameUSRaceEthnicityOut, Symbol("id"), id)
OpenAPI.validate_property(PersonalNameUSRaceEthnicityOut, Symbol("explanation"), explanation)
OpenAPI.validate_property(PersonalNameUSRaceEthnicityOut, Symbol("name"), name)
OpenAPI.validate_property(PersonalNameUSRaceEthnicityOut, Symbol("raceEthnicityAlt"), raceEthnicityAlt)
OpenAPI.validate_property(PersonalNameUSRaceEthnicityOut, Symbol("raceEthnicity"), raceEthnicity)
OpenAPI.validate_property(PersonalNameUSRaceEthnicityOut, Symbol("score"), score)
OpenAPI.validate_property(PersonalNameUSRaceEthnicityOut, Symbol("raceEthnicitiesTop"), raceEthnicitiesTop)
OpenAPI.validate_property(PersonalNameUSRaceEthnicityOut, Symbol("probabilityCalibrated"), probabilityCalibrated)
OpenAPI.validate_property(PersonalNameUSRaceEthnicityOut, Symbol("probabilityAltCalibrated"), probabilityAltCalibrated)
return new(script, id, explanation, name, raceEthnicityAlt, raceEthnicity, score, raceEthnicitiesTop, probabilityCalibrated, probabilityAltCalibrated, )
end
end # type PersonalNameUSRaceEthnicityOut
const _property_types_PersonalNameUSRaceEthnicityOut = Dict{Symbol,String}(Symbol("script")=>"String", Symbol("id")=>"String", Symbol("explanation")=>"String", Symbol("name")=>"String", Symbol("raceEthnicityAlt")=>"String", Symbol("raceEthnicity")=>"String", Symbol("score")=>"Float64", Symbol("raceEthnicitiesTop")=>"Vector{String}", Symbol("probabilityCalibrated")=>"Float64", Symbol("probabilityAltCalibrated")=>"Float64", )
OpenAPI.property_type(::Type{ PersonalNameUSRaceEthnicityOut }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_PersonalNameUSRaceEthnicityOut[name]))}
function check_required(o::PersonalNameUSRaceEthnicityOut)
true
end
function OpenAPI.validate_property(::Type{ PersonalNameUSRaceEthnicityOut }, name::Symbol, val)
if name === Symbol("raceEthnicityAlt")
OpenAPI.validate_param(name, "PersonalNameUSRaceEthnicityOut", :enum, val, ["W_NL", "HL", "A", "B_NL", "AI_AN", "PI"])
end
if name === Symbol("raceEthnicity")
OpenAPI.validate_param(name, "PersonalNameUSRaceEthnicityOut", :enum, val, ["W_NL", "HL", "A", "B_NL", "AI_AN", "PI"])
end
if name === Symbol("score")
OpenAPI.validate_param(name, "PersonalNameUSRaceEthnicityOut", :format, val, "double")
end
if name === Symbol("score")
OpenAPI.validate_param(name, "PersonalNameUSRaceEthnicityOut", :maximum, val, 100, false)
OpenAPI.validate_param(name, "PersonalNameUSRaceEthnicityOut", :minimum, val, 0, false)
end
if name === Symbol("probabilityCalibrated")
OpenAPI.validate_param(name, "PersonalNameUSRaceEthnicityOut", :format, val, "double")
end
if name === Symbol("probabilityCalibrated")
OpenAPI.validate_param(name, "PersonalNameUSRaceEthnicityOut", :maximum, val, 1, false)
OpenAPI.validate_param(name, "PersonalNameUSRaceEthnicityOut", :minimum, val, -1, false)
end
if name === Symbol("probabilityAltCalibrated")
OpenAPI.validate_param(name, "PersonalNameUSRaceEthnicityOut", :format, val, "double")
end
if name === Symbol("probabilityAltCalibrated")
OpenAPI.validate_param(name, "PersonalNameUSRaceEthnicityOut", :maximum, val, 1, false)
OpenAPI.validate_param(name, "PersonalNameUSRaceEthnicityOut", :minimum, val, -1, false)
end
end
| NamSor | https://github.com/NeroBlackstone/NamSor.jl.git |
|
[
"MIT"
] | 0.1.0 | 2d6ab091a1f4af72f40a76fe35b2c01982aa0bbf | code | 2994 | # This file was generated by the Julia OpenAPI Code Generator
# Do not modify this file directly. Modify the OpenAPI specification instead.
@doc raw"""ProperNounCategorizedOut
Classified typed proper names
ProperNounCategorizedOut(;
script=nothing,
id=nothing,
explanation=nothing,
name=nothing,
commonType=nothing,
commonTypeAlt=nothing,
score=nothing,
)
- script::String
- id::String
- explanation::String
- name::String : The input name
- commonType::String : The most likely common name type
- commonTypeAlt::String : Best alternative for : The most likely common name type
- score::Float64 : Higher score is better, but score is not normalized. Use calibratedProbability if available.
"""
Base.@kwdef mutable struct ProperNounCategorizedOut <: OpenAPI.APIModel
script::Union{Nothing, String} = nothing
id::Union{Nothing, String} = nothing
explanation::Union{Nothing, String} = nothing
name::Union{Nothing, String} = nothing
commonType::Union{Nothing, String} = nothing
commonTypeAlt::Union{Nothing, String} = nothing
score::Union{Nothing, Float64} = nothing
function ProperNounCategorizedOut(script, id, explanation, name, commonType, commonTypeAlt, score, )
OpenAPI.validate_property(ProperNounCategorizedOut, Symbol("script"), script)
OpenAPI.validate_property(ProperNounCategorizedOut, Symbol("id"), id)
OpenAPI.validate_property(ProperNounCategorizedOut, Symbol("explanation"), explanation)
OpenAPI.validate_property(ProperNounCategorizedOut, Symbol("name"), name)
OpenAPI.validate_property(ProperNounCategorizedOut, Symbol("commonType"), commonType)
OpenAPI.validate_property(ProperNounCategorizedOut, Symbol("commonTypeAlt"), commonTypeAlt)
OpenAPI.validate_property(ProperNounCategorizedOut, Symbol("score"), score)
return new(script, id, explanation, name, commonType, commonTypeAlt, score, )
end
end # type ProperNounCategorizedOut
const _property_types_ProperNounCategorizedOut = Dict{Symbol,String}(Symbol("script")=>"String", Symbol("id")=>"String", Symbol("explanation")=>"String", Symbol("name")=>"String", Symbol("commonType")=>"String", Symbol("commonTypeAlt")=>"String", Symbol("score")=>"Float64", )
OpenAPI.property_type(::Type{ ProperNounCategorizedOut }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_ProperNounCategorizedOut[name]))}
function check_required(o::ProperNounCategorizedOut)
true
end
function OpenAPI.validate_property(::Type{ ProperNounCategorizedOut }, name::Symbol, val)
if name === Symbol("score")
OpenAPI.validate_param(name, "ProperNounCategorizedOut", :format, val, "double")
end
if name === Symbol("score")
OpenAPI.validate_param(name, "ProperNounCategorizedOut", :maximum, val, 100, false)
OpenAPI.validate_param(name, "ProperNounCategorizedOut", :minimum, val, 0, false)
end
end
| NamSor | https://github.com/NeroBlackstone/NamSor.jl.git |
|
[
"MIT"
] | 0.1.0 | 2d6ab091a1f4af72f40a76fe35b2c01982aa0bbf | code | 2584 | # This file was generated by the Julia OpenAPI Code Generator
# Do not modify this file directly. Modify the OpenAPI specification instead.
@doc raw"""RegionISO
List of countries and regions
RegionISO(;
countryName=nothing,
countryNumCode=nothing,
countryISO2=nothing,
countryISO3=nothing,
countryFIPS=nothing,
subregion=nothing,
region=nothing,
topregion=nothing,
)
- countryName::String
- countryNumCode::String
- countryISO2::String
- countryISO3::String
- countryFIPS::String
- subregion::String
- region::String
- topregion::String
"""
Base.@kwdef mutable struct RegionISO <: OpenAPI.APIModel
countryName::Union{Nothing, String} = nothing
countryNumCode::Union{Nothing, String} = nothing
countryISO2::Union{Nothing, String} = nothing
countryISO3::Union{Nothing, String} = nothing
countryFIPS::Union{Nothing, String} = nothing
subregion::Union{Nothing, String} = nothing
region::Union{Nothing, String} = nothing
topregion::Union{Nothing, String} = nothing
function RegionISO(countryName, countryNumCode, countryISO2, countryISO3, countryFIPS, subregion, region, topregion, )
OpenAPI.validate_property(RegionISO, Symbol("countryName"), countryName)
OpenAPI.validate_property(RegionISO, Symbol("countryNumCode"), countryNumCode)
OpenAPI.validate_property(RegionISO, Symbol("countryISO2"), countryISO2)
OpenAPI.validate_property(RegionISO, Symbol("countryISO3"), countryISO3)
OpenAPI.validate_property(RegionISO, Symbol("countryFIPS"), countryFIPS)
OpenAPI.validate_property(RegionISO, Symbol("subregion"), subregion)
OpenAPI.validate_property(RegionISO, Symbol("region"), region)
OpenAPI.validate_property(RegionISO, Symbol("topregion"), topregion)
return new(countryName, countryNumCode, countryISO2, countryISO3, countryFIPS, subregion, region, topregion, )
end
end # type RegionISO
const _property_types_RegionISO = Dict{Symbol,String}(Symbol("countryName")=>"String", Symbol("countryNumCode")=>"String", Symbol("countryISO2")=>"String", Symbol("countryISO3")=>"String", Symbol("countryFIPS")=>"String", Symbol("subregion")=>"String", Symbol("region")=>"String", Symbol("topregion")=>"String", )
OpenAPI.property_type(::Type{ RegionISO }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_RegionISO[name]))}
function check_required(o::RegionISO)
true
end
function OpenAPI.validate_property(::Type{ RegionISO }, name::Symbol, val)
end
| NamSor | https://github.com/NeroBlackstone/NamSor.jl.git |
|
[
"MIT"
] | 0.1.0 | 2d6ab091a1f4af72f40a76fe35b2c01982aa0bbf | code | 1054 | # This file was generated by the Julia OpenAPI Code Generator
# Do not modify this file directly. Modify the OpenAPI specification instead.
@doc raw"""RegionOut
RegionOut(;
countriesAndRegions=nothing,
)
- countriesAndRegions::Vector{RegionISO} : List of countries and regions
"""
Base.@kwdef mutable struct RegionOut <: OpenAPI.APIModel
countriesAndRegions::Union{Nothing, Vector} = nothing # spec type: Union{ Nothing, Vector{RegionISO} }
function RegionOut(countriesAndRegions, )
OpenAPI.validate_property(RegionOut, Symbol("countriesAndRegions"), countriesAndRegions)
return new(countriesAndRegions, )
end
end # type RegionOut
const _property_types_RegionOut = Dict{Symbol,String}(Symbol("countriesAndRegions")=>"Vector{RegionISO}", )
OpenAPI.property_type(::Type{ RegionOut }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_RegionOut[name]))}
function check_required(o::RegionOut)
true
end
function OpenAPI.validate_property(::Type{ RegionOut }, name::Symbol, val)
end
| NamSor | https://github.com/NeroBlackstone/NamSor.jl.git |
|
[
"MIT"
] | 0.1.0 | 2d6ab091a1f4af72f40a76fe35b2c01982aa0bbf | code | 1311 | # This file was generated by the Julia OpenAPI Code Generator
# Do not modify this file directly. Modify the OpenAPI specification instead.
@doc raw"""ReligionStatOut
Geographic religious statistics, assuming country is correctly predicted.
ReligionStatOut(;
religion=nothing,
pct=nothing,
)
- religion::String
- pct::Float64
"""
Base.@kwdef mutable struct ReligionStatOut <: OpenAPI.APIModel
religion::Union{Nothing, String} = nothing
pct::Union{Nothing, Float64} = nothing
function ReligionStatOut(religion, pct, )
OpenAPI.validate_property(ReligionStatOut, Symbol("religion"), religion)
OpenAPI.validate_property(ReligionStatOut, Symbol("pct"), pct)
return new(religion, pct, )
end
end # type ReligionStatOut
const _property_types_ReligionStatOut = Dict{Symbol,String}(Symbol("religion")=>"String", Symbol("pct")=>"Float64", )
OpenAPI.property_type(::Type{ ReligionStatOut }, name::Symbol) = Union{Nothing,eval(Base.Meta.parse(_property_types_ReligionStatOut[name]))}
function check_required(o::ReligionStatOut)
true
end
function OpenAPI.validate_property(::Type{ ReligionStatOut }, name::Symbol, val)
if name === Symbol("pct")
OpenAPI.validate_param(name, "ReligionStatOut", :format, val, "double")
end
end
| NamSor | https://github.com/NeroBlackstone/NamSor.jl.git |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.