@cyclonedx/cyclonedx-library/dist.d/serialize/json/normalize.d.ts

Core functionality of CycloneDX for JavaScript (Node.js or WebBrowser).

/*!
This file is part of CycloneDX JavaScript Library.

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

   http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.

SPDX-License-Identifier: Apache-2.0
Copyright (c) OWASP Foundation. All Rights Reserved.
*/
import type { SortableIterable } from '../../_helpers/sortable';
import type * as Models from '../../models';
import type { _SpecProtocol as Spec } from '../../spec/_protocol';
import type { NormalizerOptions } from '../types';
import type { Normalized } from './types';
export declare class Factory {
    #private;
    constructor(spec: Factory['spec']);
    get spec(): Spec;
    makeForBom(): BomNormalizer;
    makeForMetadata(): MetadataNormalizer;
    makeForComponent(): ComponentNormalizer;
    makeForService(): ServiceNormalizer;
    makeForComponentEvidence(): ComponentEvidenceNormalizer;
    makeForLifecycle(): LifecycleNormalizer;
    makeForTool(): ToolNormalizer;
    makeForTools(): ToolsNormalizer;
    makeForOrganizationalContact(): OrganizationalContactNormalizer;
    makeForOrganizationalEntity(): OrganizationalEntityNormalizer;
    makeForHash(): HashNormalizer;
    makeForLicense(): LicenseNormalizer;
    makeForSWID(): SWIDNormalizer;
    makeForExternalReference(): ExternalReferenceNormalizer;
    makeForAttachment(): AttachmentNormalizer;
    makeForProperty(): PropertyNormalizer;
    makeForDependencyGraph(): DependencyGraphNormalizer;
    makeForVulnerability(): VulnerabilityNormalizer;
    makeForVulnerabilitySource(): VulnerabilitySourceNormalizer;
    makeForVulnerabilityReference(): VulnerabilityReferenceNormalizer;
    makeForVulnerabilityRating(): VulnerabilityRatingNormalizer;
    makeForVulnerabilityAdvisory(): VulnerabilityAdvisoryNormalizer;
    makeForVulnerabilityCredits(): VulnerabilityCreditsNormalizer;
    makeForVulnerabilityAffect(): VulnerabilityAffectNormalizer;
    makeForVulnerabilityAffectedVersion(): VulnerabilityAffectedVersionNormalizer;
    makeForVulnerabilityAnalysis(): VulnerabilityAnalysisNormalizer;
}
interface JsonNormalizer<TModel, TNormalized> {
    normalize: (data: TModel, options: NormalizerOptions) => TNormalized | undefined;
    normalizeIterable?: (data: SortableIterable<TModel>, options: NormalizerOptions) => TNormalized[];
}
declare abstract class BaseJsonNormalizer<TModel, TNormalized = object> implements JsonNormalizer<TModel, TNormalized> {
    protected readonly _factory: Factory;
    constructor(factory: Factory);
    get factory(): Factory;
    abstract normalize(data: TModel, options: NormalizerOptions): TNormalized | undefined;
}
export declare class BomNormalizer extends BaseJsonNormalizer<Models.Bom> {
    #private;
    normalize(data: Models.Bom, options: NormalizerOptions): Normalized.Bom;
}
export declare class MetadataNormalizer extends BaseJsonNormalizer<Models.Metadata> {
    normalize(data: Models.Metadata, options: NormalizerOptions): Normalized.Metadata;
}
export declare class LifecycleNormalizer extends BaseJsonNormalizer<Models.Lifecycle> {
    normalize(data: Models.Lifecycle, options: NormalizerOptions): Normalized.Lifecycle;
    normalizeIterable(data: SortableIterable<Models.Lifecycle>, options: NormalizerOptions): Normalized.Lifecycle[];
}
export declare class ToolNormalizer extends BaseJsonNormalizer<Models.Tool> {
    normalize(data: Models.Tool, options: NormalizerOptions): Normalized.Tool;
    normalizeIterable(data: SortableIterable<Models.Tool>, options: NormalizerOptions): Normalized.Tool[];
}
export declare class ToolsNormalizer extends BaseJsonNormalizer<Models.Tools> {
    normalize(data: Models.Tools, options: NormalizerOptions): Normalized.ToolsType;
}
export declare class HashNormalizer extends BaseJsonNormalizer<Models.Hash> {
    normalize([algorithm, content]: Models.Hash, options: NormalizerOptions): Normalized.Hash | undefined;
    normalizeIterable(data: SortableIterable<Models.Hash>, options: NormalizerOptions): Normalized.Hash[];
}
export declare class OrganizationalContactNormalizer extends BaseJsonNormalizer<Models.OrganizationalContact> {
    normalize(data: Models.OrganizationalContact, options: NormalizerOptions): Normalized.OrganizationalContact;
    normalizeIterable(data: SortableIterable<Models.OrganizationalContact>, options: NormalizerOptions): Normalized.OrganizationalContact[];
}
export declare class OrganizationalEntityNormalizer extends BaseJsonNormalizer<Models.OrganizationalEntity> {
    normalize(data: Models.OrganizationalEntity, options: NormalizerOptions): Normalized.OrganizationalEntity;
    normalizeIterable(data: SortableIterable<Models.OrganizationalEntity>, options: NormalizerOptions): Normalized.OrganizationalEntity[];
}
export declare class ComponentNormalizer extends BaseJsonNormalizer<Models.Component> {
    normalize(data: Models.Component, options: NormalizerOptions): Normalized.Component | undefined;
    normalizeIterable(data: SortableIterable<Models.Component>, options: NormalizerOptions): Normalized.Component[];
}
export declare class ServiceNormalizer extends BaseJsonNormalizer<Models.Service> {
    normalize(data: Models.Service, options: NormalizerOptions): Normalized.Service;
    normalizeIterable(data: SortableIterable<Models.Service>, options: NormalizerOptions): Normalized.Service[];
}
export declare class ComponentEvidenceNormalizer extends BaseJsonNormalizer<Models.ComponentEvidence> {
    #private;
    normalize(data: Models.ComponentEvidence, options: NormalizerOptions): Normalized.ComponentEvidence;
}
export declare class LicenseNormalizer extends BaseJsonNormalizer<Models.License> {
    #private;
    normalize(data: Models.License, options: NormalizerOptions): Normalized.License;
    /**
     * If there is any {@link Models.LicenseExpression | LicenseExpression} in the set, then this is the only item that is normalized.
     */
    normalizeIterable(data: SortableIterable<Models.License>, options: NormalizerOptions): Normalized.License[];
}
export declare class SWIDNormalizer extends BaseJsonNormalizer<Models.SWID> {
    normalize(data: Models.SWID, options: NormalizerOptions): Normalized.SWID;
}
export declare class ExternalReferenceNormalizer extends BaseJsonNormalizer<Models.ExternalReference> {
    normalize(data: Models.ExternalReference, options: NormalizerOptions): Normalized.ExternalReference | undefined;
    normalizeIterable(data: SortableIterable<Models.ExternalReference>, options: NormalizerOptions): Normalized.ExternalReference[];
}
export declare class AttachmentNormalizer extends BaseJsonNormalizer<Models.Attachment> {
    normalize(data: Models.Attachment, options: NormalizerOptions): Normalized.Attachment;
}
export declare class PropertyNormalizer extends BaseJsonNormalizer<Models.Property> {
    normalize(data: Models.Property, options: NormalizerOptions): Normalized.Property;
    normalizeIterable(data: SortableIterable<Models.Property>, options: NormalizerOptions): Normalized.Property[];
}
export declare class DependencyGraphNormalizer extends BaseJsonNormalizer<Models.Bom> {
    #private;
    normalize(data: Models.Bom, options: NormalizerOptions): Normalized.Dependency[] | undefined;
}
export declare class VulnerabilityNormalizer extends BaseJsonNormalizer<Models.Vulnerability.Vulnerability> {
    normalize(data: Models.Vulnerability.Vulnerability, options: NormalizerOptions): Normalized.Vulnerability;
    normalizeIterable(data: SortableIterable<Models.Vulnerability.Vulnerability>, options: NormalizerOptions): Normalized.Vulnerability[];
}
export declare class VulnerabilitySourceNormalizer extends BaseJsonNormalizer<Models.Vulnerability.Source> {
    normalize(data: Models.Vulnerability.Source, options: NormalizerOptions): Normalized.Vulnerability.Source;
}
export declare class VulnerabilityReferenceNormalizer extends BaseJsonNormalizer<Models.Vulnerability.Reference> {
    normalize(data: Models.Vulnerability.Reference, options: NormalizerOptions): Normalized.Vulnerability.Reference;
    normalizeIterable(data: SortableIterable<Models.Vulnerability.Reference>, options: NormalizerOptions): Normalized.Vulnerability.Reference[];
}
export declare class VulnerabilityRatingNormalizer extends BaseJsonNormalizer<Models.Vulnerability.Rating> {
    normalize(data: Models.Vulnerability.Rating, options: NormalizerOptions): Normalized.Vulnerability.Rating;
    normalizeIterable(data: SortableIterable<Models.Vulnerability.Rating>, options: NormalizerOptions): Normalized.Vulnerability.Rating[];
}
export declare class VulnerabilityAdvisoryNormalizer extends BaseJsonNormalizer<Models.Vulnerability.Advisory> {
    normalize(data: Models.Vulnerability.Advisory, options: NormalizerOptions): Normalized.Vulnerability.Advisory | undefined;
    normalizeIterable(data: SortableIterable<Models.Vulnerability.Advisory>, options: NormalizerOptions): Normalized.Vulnerability.Advisory[];
}
export declare class VulnerabilityCreditsNormalizer extends BaseJsonNormalizer<Models.Vulnerability.Credits> {
    normalize(data: Models.Vulnerability.Credits, options: NormalizerOptions): Normalized.Vulnerability.Credits;
}
export declare class VulnerabilityAffectNormalizer extends BaseJsonNormalizer<Models.Vulnerability.Affect> {
    normalize(data: Models.Vulnerability.Affect, options: NormalizerOptions): Normalized.Vulnerability.Affect;
    normalizeIterable(data: SortableIterable<Models.Vulnerability.Affect>, options: NormalizerOptions): Normalized.Vulnerability.Affect[];
}
export declare class VulnerabilityAffectedVersionNormalizer extends BaseJsonNormalizer<Models.Vulnerability.AffectedVersion> {
    #private;
    normalize(data: Models.Vulnerability.AffectedVersion, options: NormalizerOptions): Normalized.Vulnerability.AffectedVersion | undefined;
    normalizeIterable(data: SortableIterable<Models.Vulnerability.AffectedVersion>, options: NormalizerOptions): Normalized.Vulnerability.AffectedVersion[];
}
export declare class VulnerabilityAnalysisNormalizer extends BaseJsonNormalizer<Models.Vulnerability.Analysis> {
    normalize(data: Models.Vulnerability.Analysis, options: NormalizerOptions): Normalized.Vulnerability.Analysis;
}
export {};
//# sourceMappingURL=normalize.d.ts.map