policy

type Account struct {
	Id                   string `json:"id"`
	Key                  string `json:"Key"`
	CertificateAuthority string `json:"certificateAuthority"`
}

type AccountDetails struct {
	Account       Account         `json:"account"`
	ProductOption []ProductOption `json:"productOptions"`
}

type Accounts struct {
	Accounts []AccountDetails
}

type Application struct {
	OwnerIdsAndTypes                     []OwnerIdType     `json:"ownerIdsAndTypes"`
	Name                                 string            `json:"name"`
	Description                          string            `json:"description"`
	Fqdns                                []string          `json:"fqdns"`
	InternalFqdns                        []string          `json:"internalFqdns"`
	InternalIpRanges                     []string          `json:"internalIpRanges"`
	ExternalIpRanges                     []string          `json:"externalIpRanges"`
	InternalPorts                        []string          `json:"internalPorts"`
	FullyQualifiedDomainNames            []string          `json:"fullyQualifiedDomainNames"`
	IpRanges                             []string          `json:"ipRanges"`
	Ports                                []string          `json:"ports"`
	CertificateIssuingTemplateAliasIdMap map[string]string `json:"certificateIssuingTemplateAliasIdMap"`
	StartTargetedDiscovery               bool              `json:"startTargetedDiscovery"`
}

type CADetails struct {
	CertificateAuthorityProductOptionId *string
	CertificateAuthorityOrganizationId  *int64
}

type CertificateAuthorityInfo struct {
	CAType            string
	CAAccountKey      string
	VendorProductName string
}

type CheckPolicyRequest struct {
	PolicyDN string `json:"PolicyDN"`
}

type CheckPolicyResponse struct {
	Error  string          `json:"Error"`
	Policy *PolicyResponse `json:"Policy"`
}

type ClearTTPAttributesRequest struct {
	ObjectDN      string `json:"ObjectDN"`
	Class         string `json:"Class"`
	AttributeName string `json:"AttributeName"`
}

type CloudPolicyRequest struct {
	Name                                string               `json:"name"`
	CertificateAuthority                string               `json:"certificateAuthority"`
	CertificateAuthorityProductOptionId string               `json:"certificateAuthorityProductOptionId"`
	Product                             Product              `json:"product"`
	TrackingData                        *TrackingData        `json:"trackingData"`
	SubjectCNRegexes                    []string             `json:"subjectCNRegexes"`
	SubjectORegexes                     []string             `json:"subjectORegexes"`
	SubjectOURegexes                    []string             `json:"subjectOURegexes"`
	SubjectLRegexes                     []string             `json:"subjectLRegexes"`
	SubjectSTRegexes                    []string             `json:"subjectSTRegexes"`
	SubjectCValues                      []string             `json:"subjectCValues"`
	SanRegexes                          []string             `json:"sanRegexes"`
	SanIpAddressRegexes                 []string             `json:"sanIpAddressRegexes"`
	SanRfc822NameRegexes                []string             `json:"sanRfc822NameRegexes"`
	SanUniformResourceIdentifierRegexes []string             `json:"sanUniformResourceIdentifierRegexes"`
	KeyTypes                            []KeyType            `json:"keyTypes,omitempty"`
	KeyAlgorithmTypes                   []KeyType            `json:"keyAlgorithmTypes,omitempty"`
	KeyReuse                            *bool                `json:"keyReuse"`
	RecommendedSettings                 *RecommendedSettings `json:"recommendedSettings"`
	CsrUploadAllowed                    bool                 `json:"csrUploadAllowed"`
	KeyGeneratedByVenafiAllowed         bool                 `json:"keyGeneratedByVenafiAllowed"`
}

type DecodedPkixParameterSet struct {
	// Oids are the OIDs the server returned that this version of vcert recognized, in the order
	// the server returned them.
	Oids []string
	// KeyTypes holds the distinct key algorithm names ("RSA", "ECC", "MLDSA") covered by Oids.
	KeyTypes []string
	// RsaKeySizes, EllipticCurves and MLDSAKeyStrengths hold the RSA bit sizes, curve names and ML-DSA strengths
	// covered by Oids.
	RsaKeySizes       []int
	EllipticCurves    []string
	MLDSAKeyStrengths []int
}

type Default struct {
	Domain        *string         `json:"domain,omitempty" yaml:"domain,omitempty"`
	Subject       *DefaultSubject `json:"subject,omitempty" yaml:"subject,omitempty"`
	KeyPair       *DefaultKeyPair `json:"keyPair,omitempty" yaml:"keyPair,omitempty"`
	AutoInstalled *bool           `json:"autoInstalled,omitempty" yaml:"autoInstalled,omitempty"`
}

type DefaultKeyPair struct {
	PkixParameterSetDefault *string `json:"pkixParameterSetDefault,omitempty" yaml:"pkixParameterSetDefault,omitempty"`
	KeyType                 *string `json:"keyType,omitempty" yaml:"keyType,omitempty"`
	RsaKeySize              *int    `json:"rsaKeySize,omitempty" yaml:"rsaKeySize,omitempty"`
	EllipticCurve           *string `json:"ellipticCurve,omitempty" yaml:"ellipticCurve,omitempty"`
	// MLDSAKeyStrength is the default ML-DSA strength (44, 65 or 87) when KeyType is MLDSA
	MLDSAKeyStrength *int  `json:"mldsaKeyStrength,omitempty" yaml:"mldsaKeyStrength,omitempty"`
	ServiceGenerated *bool `json:"serviceGenerated,omitempty" yaml:"serviceGenerated,omitempty"`
}

type DefaultSubject struct {
	Org      *string  `json:"org,omitempty" yaml:"org,omitempty"`
	OrgUnits []string `json:"orgUnits,omitempty" yaml:"orgUnits,omitempty"`
	Locality *string  `json:"locality,omitempty" yaml:"locality,omitempty"`
	State    *string  `json:"state,omitempty" yaml:"state,omitempty"`
	Country  *string  `json:"country,omitempty" yaml:"country,omitempty"`
}

type Key struct {
	Type   string `json:"type"`
	Length int    `json:"length,omitempty"`
	Curve  string `json:"curve,omitempty"`
}

type KeyAlgorithm struct {
	KeyType     string `json:"keyType"`
	KeyLength   int    `json:"keyLength,omitempty"`
	KeyCurve    string `json:"keyCurve,omitempty"`
	KeyStrength int    `json:"keyStrength,omitempty"`
}

type KeyPair struct {
	PkixParameterSet []string `json:"pkixParameterSet,omitempty" yaml:"pkixParameterSet,omitempty"`
	KeyTypes         []string `json:"keyTypes,omitempty" yaml:"keyTypes,omitempty"`
	RsaKeySizes      []int    `json:"rsaKeySizes,omitempty" yaml:"rsaKeySizes,omitempty"`
	EllipticCurves   []string `json:"ellipticCurves,omitempty" yaml:"ellipticCurves,omitempty"`
	// MLDSAKeyStrengths are the ML-DSA strengths (44, 65, 87) allowed when KeyTypes includes MLDSA
	MLDSAKeyStrengths []int `json:"mldsaKeyStrengths,omitempty" yaml:"mldsaKeyStrengths,omitempty"`
	ServiceGenerated  *bool `json:"serviceGenerated,omitempty" yaml:"generationType,omitempty"`
	ReuseAllowed      *bool `json:"reuseAllowed,omitempty" yaml:"reuseAllowed,omitempty"`
}

type KeyPairResponse struct {
	KeyAlgorithm  LockedAttribute    `json:"KeyAlgorithm"`
	KeySize       LockedIntAttribute `json:"KeySize"`
	EllipticCurve LockedAttribute    `json:"EllipticCurve"`
	// PkixParameterSet lists the PKIX OIDs of the key algorithms allowed by policy. Available
	// from TPP 25.1 onwards, it supersedes KeyAlgorithm/KeySize/EllipticCurve above, which TPP
	// no longer locks once a policy folder's allowed algorithms are configured via the newer
	// AlgorithmSelector API.
	//
	// Locked is true whenever the folder has an effective allowed set, which on TPP 25.1+ is
	// always. It does not distinguish a folder an administrator restricted from one that merely
	// permits everything the server supports.
	PkixParameterSet LockedArrayAttribute `json:"PkixParameterSet"`
	// DefaultPkixParameterSet is the single PKIX OID the folder recommends, i.e. the "PKIX
	// Parameter Set Policy Default" attribute. It is a separate attribute from PkixParameterSet
	// and must be read separately: a folder that locks its allowed set still has a default.
	DefaultPkixParameterSet LockedAttribute `json:"DefaultPkixParameterSet"`
}

type KeyType struct {
	KeyType      string   `json:"keyType"`
	KeyLengths   []int    `json:"keyLengths,omitempty"`
	KeyCurves    []string `json:"keyCurves,omitempty"`
	KeyStrengths []int    `json:"keyStrengths,omitempty"`
}

type LockedArrayAttribute struct {
	Value  []string `json:"Values"`
	Locked bool
}

type LockedAttribute struct {
	Value  string
	Locked bool
}

type LockedIntAttribute struct {
	Value  int
	Locked bool
}

type OwnerIdType struct {
	OwnerId   string `json:"ownerId"`
	OwnerType string `json:"ownerType"`
}

type PkixOidKeyAlgorithm struct {
	// KeyType is the key algorithm name spelled as KeyAlgorithmsToPKIX and a policy
	// specification's keyTypes field spell it, i.e. "RSA", "ECC" or "MLDSA".
	KeyType string
	KeySize int    // populated for RSA (bit size) and MLDSA (strength: 44, 65 or 87)
	Curve   string // populated for ECC, e.g. "P256"
}

type Policy struct {
	Domains              []string         `json:"domains,omitempty" yaml:"domains,omitempty"`
	WildcardAllowed      *bool            `json:"wildcardAllowed,omitempty" yaml:"wildcardAllowed,omitempty"`
	AutoInstalled        *bool            `json:"autoInstalled,omitempty" yaml:"autoInstalled,omitempty"`
	MaxValidDays         *int             `json:"maxValidDays,omitempty" yaml:"maxValidDays,omitempty"`
	CertificateAuthority *string          `json:"certificateAuthority,omitempty" yaml:"certificateAuthority,omitempty"`
	Subject              *Subject         `json:"subject,omitempty" yaml:"subject,omitempty"`
	KeyPair              *KeyPair         `json:"keyPair,omitempty" yaml:"keyPair,omitempty"`
	SubjectAltNames      *SubjectAltNames `json:"subjectAltNames,omitempty" yaml:"subjectAltNames,omitempty"`
}

type PolicyExistPayloadRequest struct {
	ObjectDN string `json:"ObjectDN"`
}

type PolicyGetAttributePayloadRequest struct {
	ObjectDN      string   `json:"ObjectDN"`
	Class         string   `json:"Class"`
	AttributeName string   `json:"AttributeName"`
	Values        []string `json:"Values"`
}

type PolicyGetAttributeResponse struct {
	Locked bool     `json:"Locked"`
	Result int      `json:"Result"`
	Values []string `json:"Values"`
}

type PolicyIsValidResponse struct {
	Error        string       `json:"Error"`
	Result       int          `json:"Result"`
	PolicyObject PolicyObject `json:"Object"`
}

type PolicyObject struct {
	AbsoluteGUID string `json:"AbsoluteGUID"`
	DN           string `json:"DN"`
	GUID         string `json:"GUID"`
	Id           int    `json:"Id"`
	Name         string `json:"Name"`
	Parent       string `json:"Parent"`
	Revision     int    `json:"Revision"`
	TypeName     string `json:"TypeName"`
}

type PolicyPayloadRequest struct {
	Class    string `json:"Class"`
	ObjectDN string `json:"ObjectDN"`
}

type PolicyResponse struct {
	CertificateAuthority    LockedAttribute `json:"CertificateAuthority"`
	CsrGeneration           LockedAttribute `json:"CsrGeneration"`
	KeyGeneration           LockedAttribute `json:"KeyGeneration"`
	KeyPairResponse         KeyPairResponse `json:"KeyPair"`
	ManagementType          LockedAttribute `json:"ManagementType"`
	PrivateKeyReuseAllowed  bool            `json:"PrivateKeyReuseAllowed"`
	SubjAltNameDnsAllowed   bool            `json:"SubjAltNameDnsAllowed"`
	SubjAltNameEmailAllowed bool            `json:"SubjAltNameEmailAllowed"`
	SubjAltNameIpAllowed    bool            `json:"SubjAltNameIpAllowed"`
	SubjAltNameUpnAllowed   bool            `json:"SubjAltNameUpnAllowed"`
	SubjAltNameUriAllowed   bool            `json:"SubjAltNameUriAllowed"`
	Subject                 SubjectResponse `json:"Subject"`
	UniqueSubjectEnforced   bool            `json:"UniqueSubjectEnforced"`
	WhitelistedDomains      []string        `json:"WhitelistedDomains"`
	WildcardsAllowed        bool            `json:"WildcardsAllowed"`
}

type PolicySetAttributePayloadRequest struct {
	Locked        bool     `json:"Locked"`
	ObjectDN      string   `json:"ObjectDN"`
	Class         string   `json:"Class"`
	AttributeName string   `json:"AttributeName"`
	Values        []string `json:"Values"`
}

type PolicySetAttributeResponse struct {
	Error  string `json:"Error"`
	Result int    `json:"Result"`
}

type PolicySpecification struct {
	Owners     []string `json:"owners,omitempty" yaml:"owners,omitempty"`
	Users      []string `json:"users,omitempty" yaml:"users,omitempty"`
	UserAccess string   `json:"userAccess,omitempty" yaml:"userAccess,omitempty"`
	Approvers  []string `json:"approvers,omitempty" yaml:"approvers,omitempty"`
	Policy     *Policy  `json:"policy,omitempty" yaml:"policy,omitempty"`
	Default    *Default `json:"defaults,omitempty" yaml:"defaults,omitempty"`
}

type Product struct {
	CertificateAuthority string  `json:"certificateAuthority"`
	ProductName          string  `json:"productName"`
	ValidityPeriod       string  `json:"validityPeriod"`
	HashAlgorithm        *string `json:"hashAlgorithm,omitempty"`
	AutoRenew            *bool   `json:"autoRenew,omitempty"`
	OrganizationId       *int64  `json:"organizationId,omitempty"`
}

type ProductDetails struct {
	ProductTemplate ProductTemplate `json:"productTemplate"`
}

type ProductOption struct {
	ProductName    string         `json:"productName"`
	Id             string         `json:"id"`
	ProductDetails ProductDetails `json:"productDetails"`
}

type ProductTemplate struct {
	OrganizationId int64 `json:"organizationId"`
}

type RecommendedSettings struct {
	SubjectCNRegexes []string `json:"subjectCNRegexes"`
	SubjectOValue    *string  `json:"subjectOValue"`
	SubjectOUValue   *string  `json:"subjectOUValue"`
	SubjectLValue    *string  `json:"subjectLValue"`
	SubjectSTValue   *string  `json:"subjectSTValue"`
	SubjectCValue    *string  `json:"subjectCValue"`
	SanRegexes       []string `json:"sanRegexes"`
	// Key is the recommended key when the allowed key types are set with keyTypes
	Key *Key `json:"key,omitempty"`
	// KeyAlgorithm is the recommended key when the allowed key types are set with keyAlgorithmTypes
	KeyAlgorithm *KeyAlgorithm `json:"keyAlgorithm,omitempty"`
}

type Subject struct {
	Orgs       []string `json:"orgs,omitempty" yaml:"orgs,omitempty"`
	OrgUnits   []string `json:"orgUnits,omitempty" yaml:"orgUnits,omitempty"`
	Localities []string `json:"localities,omitempty" yaml:"localities,omitempty"`
	States     []string `json:"states,omitempty" yaml:"states,omitempty"`
	Countries  []string `json:"countries,omitempty" yaml:"countries,omitempty"`
}

type SubjectAltNames struct {
	DnsAllowed    *bool    `json:"dnsAllowed,omitempty" yaml:"dnsAllowed,omitempty"`
	IpAllowed     *bool    `json:"ipAllowed,omitempty" yaml:"ipAllowed,omitempty"`
	EmailAllowed  *bool    `json:"emailAllowed,omitempty" yaml:"emailAllowed,omitempty"`
	UriAllowed    *bool    `json:"uriAllowed,omitempty" yaml:"uriAllowed,omitempty"`
	UpnAllowed    *bool    `json:"upnAllowed,omitempty" yaml:"uriProtocols,omitempty"`
	UriProtocols  []string `json:"uriProtocols,omitempty" yaml:"uriProtocols,omitempty"`
	IpConstraints []string `json:"ipConstraints,omitempty" yaml:"uriProtocols,omitempty"`
}

type SubjectResponse struct {
	City               LockedAttribute      `json:"City"`
	Country            LockedAttribute      `json:"Country"`
	Organization       LockedAttribute      `json:"Organization"`
	OrganizationalUnit LockedArrayAttribute `json:"OrganizationalUnit"`
	State              LockedAttribute      `json:"State"`
}

type TppPolicy struct {
	//general values
	Name *string
	//Owners []string "owners": string[],(permissions only)	prefixed name/universal
	Contact []string
	//Permissions string "userAccess": string,	(permissions)	prefixed name/universal
	Approver []string

	//policy's values
	ProhibitWildcard      *int
	DomainSuffixWhitelist []string
	ProhibitedSANType     []string
	CertificateAuthority  *string
	ManagementType        *LockedAttribute

	//subject attributes
	Organization       *LockedAttribute
	OrganizationalUnit *LockedArrayAttribute
	City               *LockedAttribute
	State              *LockedAttribute
	Country            *LockedAttribute

	// KeyPair attributes
	PkixParameterSetDefault *LockedAttribute
	PkixParameterSet        *LockedArrayAttribute

	KeyAlgorithm         *LockedAttribute //Deprecated in TPP 25.1, use PkixParameterSet
	KeyBitStrength       *LockedAttribute //Deprecated in TPP 25.1, use PkixParameterSet
	EllipticCurve        *LockedAttribute //Deprecated in TPP 25.1, use PkixParameterSet
	ManualCsr            *LockedAttribute
	AllowPrivateKeyReuse *int
	WantRenewal          *int
}

type TrackingData struct {
	CertificateAuthority string `json:"certificateAuthority"`
	RequesterName        string `json:"requesterName"`
	RequesterEmail       string `json:"requesterEmail"`
	RequesterPhone       string `json:"requesterPhone"`
}