export interface UmmC {
    Abstract: string;
    AccessConstraints?: AccessConstraintsType;
    AdditionalAttributes?: AdditionalAttributeType[];
    AncillaryKeywords?: string[];
    ArchiveAndDistributionInformation?: ArchiveAndDistributionInformationType;
    AssociatedDOIs?: AssociatedDoiType[];
    CollectionCitations?: ResourceCitationType[];
    CollectionDataType?: CollectionDataTypeEnum;
    CollectionProgress: CollectionProgressEnum;
    ContactGroups?: ContactGroupType[];
    ContactPersons?: ContactPersonType[];
    DataCenters: DataCenterType[];
    DataDates?: DateType[];
    DataLanguage?: string;
    DataMaturity?: DataMaturity;
    DirectDistributionInformation?: DirectDistributionInformationType;
    DirectoryNames?: DirectoryNameType[];
    DOI: DoiType;
    EntryTitle: string;
    FileNamingConvention?: FileNamingConventionType;
    ISOTopicCategories?: string[];
    LocationKeywords?: LocationKeywordType[];
    MetadataAssociations?: MetadataAssociationType[];
    MetadataDates?: DateType[];
    MetadataLanguage?: string;
    MetadataSpecification: MetadataSpecificationType;
    OtherIdentifiers?: OtherIdentifierType[];
    PaleoTemporalCoverages?: PaleoTemporalCoverageType[];
    Platforms: PlatformType[];
    ProcessingLevel: ProcessingLevelType;
    Projects?: ProjectType[];
    PublicationReferences?: PublicationReferenceType[];
    Purpose?: string;
    Quality?: string;
    RelatedUrls?: RelatedURLType[];
    ScienceKeywords: ScienceKeywordType[];
    ShortName: string;
    SpatialExtent: SpatialExtentType;
    SpatialInformation?: SpatialInformationType;
    SpatialKeywords?: string[];
    StandardProduct?: boolean;
    TemporalExtents: TemporalExtentType[];
    TemporalKeywords?: string[];
    TilingIdentificationSystems?: TilingIdentificationSystemType[];
    UseConstraints?: UseConstraintsType;
    Version: string;
    VersionDescription?: string;
}
export interface AccessConstraintsType {
    Description: string;
    Value?: number;
}
export interface AdditionalAttributeType {
    DataType: DataTypeEnum;
    Description: string;
    Group?: string;
    MeasurementResolution?: string;
    Name: string;
    ParameterRangeBegin?: string;
    ParameterRangeEnd?: string;
    ParameterUnitsOfMeasure?: string;
    ParameterValueAccuracy?: string;
    UpdateDate?: Date;
    Value?: string;
    ValueAccuracyExplanation?: string;
}
export declare enum DataTypeEnum {
    Boolean = "BOOLEAN",
    Date = "DATE",
    DateString = "DATE_STRING",
    Datetime = "DATETIME",
    DatetimeString = "DATETIME_STRING",
    Float = "FLOAT",
    Int = "INT",
    String = "STRING",
    Time = "TIME",
    TimeString = "TIME_STRING"
}
export interface ArchiveAndDistributionInformationType {
    FileArchiveInformation?: FileArchiveInformationType[];
    FileDistributionInformation?: FileDistributionInformationType[];
}
export interface FileArchiveInformationType {
    AverageFileSize?: number;
    AverageFileSizeUnit?: ArchiveDistributionUnitEnum;
    Description?: string;
    Format: string;
    FormatDescription?: string;
    FormatType?: ArchiveDistributionFormatTypeEnum;
    TotalCollectionFileSize?: number;
    TotalCollectionFileSizeUnit?: ArchiveDistributionUnitEnum;
    TotalCollectionFileSizeBeginDate?: Date;
}
export declare enum ArchiveDistributionUnitEnum {
    GB = "GB",
    KB = "KB",
    MB = "MB",
    Na = "NA",
    Pb = "PB",
    TB = "TB"
}
export declare enum ArchiveDistributionFormatTypeEnum {
    Native = "Native",
    Supported = "Supported"
}
export interface FileDistributionInformationType {
    AverageFileSize?: number;
    AverageFileSizeUnit?: ArchiveDistributionUnitEnum;
    Description?: string;
    Fees?: string;
    Format: string;
    FormatDescription?: string;
    FormatType?: ArchiveDistributionFormatTypeEnum;
    Media?: string[];
    TotalCollectionFileSize?: number;
    TotalCollectionFileSizeUnit?: ArchiveDistributionUnitEnum;
    TotalCollectionFileSizeBeginDate?: Date;
}
export interface AssociatedDoiType {
    Authority?: string;
    DOI: string;
    Title?: string;
    Type?: AssociatedDoiTypeType;
    DescriptionOfOtherType?: string;
}
export declare enum AssociatedDoiTypeType {
    ChildDataset = "Child Dataset",
    CollaborativeOtherAgency = "Collaborative/Other Agency",
    FieldCampaign = "Field Campaign",
    Other = "Other",
    ParentDataset = "Parent Dataset",
    RelatedDataset = "Related Dataset"
}
export interface ResourceCitationType {
    Creator?: string;
    DataPresentationForm?: string;
    Editor?: string;
    IssueIdentification?: string;
    OnlineResource?: OnlineResourceType;
    OtherCitationDetails?: string;
    Publisher?: string;
    ReleaseDate?: Date;
    ReleasePlace?: string;
    SeriesName?: string;
    Title?: string;
    Version?: string;
}
export interface OnlineResourceType {
    ApplicationProfile?: string;
    Description?: string;
    Function?: string;
    Linkage: string;
    MimeType?: string;
    Name?: string;
    Protocol?: string;
}
export declare enum CollectionDataTypeEnum {
    Expedited = "EXPEDITED",
    LowLatency = "LOW_LATENCY",
    NearRealTime = "NEAR_REAL_TIME",
    Other = "OTHER",
    ScienceQuality = "SCIENCE_QUALITY"
}
export declare enum CollectionProgressEnum {
    Active = "ACTIVE",
    Complete = "COMPLETE",
    Deprecated = "DEPRECATED",
    NotApplicable = "NOT APPLICABLE",
    NotProvided = "NOT PROVIDED",
    Planned = "PLANNED"
}
export interface ContactGroupType {
    ContactInformation?: ContactInformationType;
    GroupName: string;
    NonDataCenterAffiliation?: string;
    Roles: DataContactRoleEnum[];
    Uuid?: string;
}
export interface ContactInformationType {
    Addresses?: AddressType[];
    ContactInstruction?: string;
    ContactMechanisms?: ContactMechanismType[];
    RelatedUrls?: RelatedURLType[];
    ServiceHours?: string;
}
export interface AddressType {
    City?: string;
    Country?: string;
    PostalCode?: string;
    StateProvince?: string;
    StreetAddresses?: string[];
}
export interface ContactMechanismType {
    Type: ContactMechanismTypeEnum;
    Value: string;
}
export declare enum ContactMechanismTypeEnum {
    DirectLine = "Direct Line",
    Email = "Email",
    Facebook = "Facebook",
    Fax = "Fax",
    Mobile = "Mobile",
    Modem = "Modem",
    Other = "Other",
    Primary = "Primary",
    TDDTTYPhone = "TDD/TTY Phone",
    Telephone = "Telephone",
    Twitter = "Twitter",
    USTollFree = "U.S. toll free"
}
export interface RelatedURLType {
    Description?: string;
    GetData?: GetDataType;
    GetService?: GetServiceType;
    Subtype?: string;
    Type: string;
    URL: string;
    URLContentType: string;
}
export interface GetDataType {
    Checksum?: string;
    Fees?: string;
    Format: string;
    MimeType?: string;
    Size: number;
    Unit: GetDataUnit;
}
export declare enum GetDataUnit {
    GB = "GB",
    KB = "KB",
    MB = "MB",
    Pb = "PB",
    TB = "TB"
}
export interface GetServiceType {
    DataID: string;
    DataType: string;
    Format?: GetServiceTypeFormatEnum;
    FullName: string;
    MimeType: URLMIMETypeEnum;
    Protocol: Protocol;
    URI?: string[];
}
export declare enum GetServiceTypeFormatEnum {
    ASCII = "ascii",
    Binary = "binary",
    Bufr = "BUFR",
    Geotiff = "geotiff",
    Grib = "GRIB",
    Hdf4 = "HDF4",
    Hdf5 = "HDF5",
    HdfEos4 = "HDF-EOS4",
    HdfEos5 = "HDF-EOS5",
    JPEG = "jpeg",
    Kml = "kml",
    NotProvided = "Not provided",
    PNG = "png",
    Tiff = "tiff"
}
export declare enum URLMIMETypeEnum {
    ApplicationGMLXML = "application/gml+xml",
    ApplicationJSON = "application/json",
    ApplicationOctetStream = "application/octet-stream",
    ApplicationOpensearchdescriptionXML = "application/opensearchdescription+xml",
    ApplicationPDF = "application/pdf",
    ApplicationVndGoogleEarthKmlXML = "application/vnd.google-earth.kml+xml",
    ApplicationVndGoogleEarthKmz = "application/vnd.google-earth.kmz",
    ApplicationXHdf = "application/x-hdf",
    ApplicationXML = "application/xml",
    ApplicationXNetcdf = "application/x-netcdf",
    ApplicationXVndISO191392XML = "application/x-vnd.iso.19139-2+xml",
    ApplicationXhdf5 = "application/xhdf5",
    ImageBMP = "image/bmp",
    ImageGIF = "image/gif",
    ImageJPEG = "image/jpeg",
    ImagePNG = "image/png",
    ImageTiff = "image/tiff",
    ImageVndColladaXML = "image/vnd.collada+xml",
    NotProvided = "Not provided",
    TextCSV = "text/csv",
    TextHTML = "text/html",
    TextPlain = "text/plain",
    TextXML = "text/xml"
}
export declare enum Protocol {
    FTP = "FTP",
    Ftps = "FTPS",
    HTTP = "HTTP",
    HTTPS = "HTTPS",
    NotProvided = "Not provided"
}
export declare enum DataContactRoleEnum {
    DataCenterContact = "Data Center Contact",
    Investigator = "Investigator",
    MetadataAuthor = "Metadata Author",
    ScienceContact = "Science Contact",
    ScienceSoftwareDevelopment = "Science Software Development",
    TechnicalContact = "Technical Contact",
    UserServices = "User Services"
}
export interface ContactPersonType {
    ContactInformation?: ContactInformationType;
    FirstName?: string;
    LastName: string;
    MiddleName?: string;
    NonDataCenterAffiliation?: string;
    Roles: DataContactRoleEnum[];
    Uuid?: string;
    [property: string]: any;
}
export interface DoiType {
    Authority?: string;
    DOI?: string;
    PreviousVersion?: PreviousVersionType;
    Explanation?: string;
    MissingReason?: MissingReason;
}
export declare enum MissingReason {
    NotApplicable = "Not Applicable",
    Unknown = "Unknown"
}
export interface PreviousVersionType {
    Description?: string;
    DOI: string;
    Published?: Date;
    Version?: string;
}
export interface DataCenterType {
    ContactGroups?: ContactGroupType[];
    ContactInformation?: ContactInformationType;
    ContactPersons?: ContactPersonType[];
    LongName?: string;
    Roles: DataCenterRoleEnum[];
    ShortName: string;
    Uuid?: string;
}
export declare enum DataCenterRoleEnum {
    Archiver = "ARCHIVER",
    Distributor = "DISTRIBUTOR",
    Originator = "ORIGINATOR",
    Processor = "PROCESSOR"
}
export interface DateType {
    Date: Date;
    Type: LineageDateEnum;
}
export declare enum LineageDateEnum {
    Create = "CREATE",
    Delete = "DELETE",
    Review = "REVIEW",
    Update = "UPDATE"
}
export declare enum DataMaturity {
    Beta = "Beta",
    Provisional = "Provisional",
    Stage1Validation = "Stage 1 Validation",
    Stage2Validation = "Stage 2 Validation",
    Stage3Validation = "Stage 3 Validation",
    Stage4Validation = "Stage 4 Validation",
    Validated = "Validated"
}
export interface DirectDistributionInformationType {
    Region: DirectDistributionInformationRegionEnum;
    S3BucketAndObjectPrefixNames?: string[];
    S3CredentialsAPIDocumentationURL: string;
    S3CredentialsAPIEndpoint: string;
}
export declare enum DirectDistributionInformationRegionEnum {
    UsEast1 = "us-east-1",
    UsEast2 = "us-east-2",
    UsWest1 = "us-west-1",
    UsWest2 = "us-west-2"
}
export interface DirectoryNameType {
    LongName?: string;
    ShortName: string;
}
export interface FileNamingConventionType {
    Convention: string;
    Description?: string;
}
export interface LocationKeywordType {
    Category: string;
    DetailedLocation?: string;
    Subregion1?: string;
    Subregion2?: string;
    Subregion3?: string;
    Type?: string;
}
export interface MetadataAssociationType {
    Description?: string;
    EntryId: string;
    Type?: MetadataAssociateTypeEnum;
    Version?: string;
}
export declare enum MetadataAssociateTypeEnum {
    Child = "CHILD",
    Dependent = "DEPENDENT",
    Input = "INPUT",
    LargerCitationWorks = "LARGER CITATION WORKS",
    Parent = "PARENT",
    Related = "RELATED",
    ScienceAssociated = "SCIENCE ASSOCIATED"
}
export interface MetadataSpecificationType {
    Name: Name;
    URL: URL;
    Version: Version;
}
export declare enum Name {
    UmmC = "UMM-C"
}
export declare enum URL {
    HTTPSCDNEarthdataNasaGovUmmCollectionV1181 = "https://cdn.earthdata.nasa.gov/umm/collection/v1.18.1"
}
export declare enum Version {
    The1181 = "1.18.1"
}
export interface OtherIdentifierType {
    Identifier: string;
    Type: OtherIdentifierTypeType;
    DescriptionOfOtherType?: string;
}
export declare enum OtherIdentifierTypeType {
    ArchiveSetsNumber = "ArchiveSetsNumber",
    Other = "Other"
}
export interface PaleoTemporalCoverageType {
    ChronostratigraphicUnits?: ChronostratigraphicUnitType[];
    EndDate?: string;
    StartDate?: string;
}
export interface ChronostratigraphicUnitType {
    DetailedClassification?: string;
    Eon: string;
    Epoch?: string;
    Era?: string;
    Period?: string;
    Stage?: string;
}
export interface PlatformType {
    Characteristics?: CharacteristicType[];
    Instruments?: InstrumentType[];
    LongName?: string;
    ShortName: string;
    Type?: string;
}
export interface CharacteristicType {
    DataType: DataTypeEnum;
    Description: string;
    Name: string;
    Unit: string;
    Value: string;
}
export interface InstrumentType {
    Characteristics?: CharacteristicType[];
    ComposedOf?: InstrumentChildType[];
    LongName?: string;
    NumberOfInstruments?: number;
    OperationalModes?: string[];
    ShortName: string;
    Technique?: string;
}
export interface InstrumentChildType {
    Characteristics?: CharacteristicType[];
    LongName?: string;
    ShortName: string;
    Technique?: string;
}
export interface ProcessingLevelType {
    Id: string;
    ProcessingLevelDescription?: string;
}
export interface ProjectType {
    Campaigns?: string[];
    EndDate?: Date;
    LongName?: string;
    ShortName: string;
    StartDate?: Date;
}
export interface PublicationReferenceType {
    Author?: string;
    DOI?: DoiDoiType;
    Edition?: string;
    ISBN?: string;
    Issue?: string;
    OnlineResource?: OnlineResourceType;
    OtherReferenceDetails?: string;
    Pages?: string;
    PublicationDate?: Date;
    PublicationPlace?: string;
    Publisher?: string;
    ReportNumber?: string;
    Series?: string;
    Title?: string;
    Volume?: string;
}
export interface DoiDoiType {
    Authority?: string;
    DOI: string;
}
export interface ScienceKeywordType {
    Category: string;
    DetailedVariable?: string;
    Term: string;
    Topic: string;
    VariableLevel1?: string;
    VariableLevel2?: string;
    VariableLevel3?: string;
}
export interface SpatialExtentType {
    GranuleSpatialRepresentation: GranuleSpatialRepresentationEnum;
    HorizontalSpatialDomain?: HorizontalSpatialDomainType;
    OrbitParameters?: OrbitParametersType;
    SpatialCoverageType?: SpatialCoverageTypeEnum;
    VerticalSpatialDomains?: VerticalSpatialDomainType[];
}
export declare enum GranuleSpatialRepresentationEnum {
    Cartesian = "CARTESIAN",
    Geodetic = "GEODETIC",
    NoSpatial = "NO_SPATIAL",
    Orbit = "ORBIT"
}
export interface HorizontalSpatialDomainType {
    Geometry: GeometryType;
    ResolutionAndCoordinateSystem?: ResolutionAndCoordinateSystemType;
    ZoneIdentifier?: string;
}
export interface GeometryType {
    BoundingRectangles?: BoundingRectangleType[];
    CoordinateSystem: CoordinateSystemEnum;
    GPolygons?: GPolygonType[];
    Lines?: LineType[];
    Points?: PointType[];
}
export interface BoundingRectangleType {
    EastBoundingCoordinate: number;
    NorthBoundingCoordinate: number;
    SouthBoundingCoordinate: number;
    WestBoundingCoordinate: number;
}
export declare enum CoordinateSystemEnum {
    Cartesian = "CARTESIAN",
    Geodetic = "GEODETIC"
}
export interface GPolygonType {
    Boundary: BoundaryType;
    ExclusiveZone?: ExclusiveZoneType;
}
export interface BoundaryType {
    Points: PointType[];
}
export interface PointType {
    Latitude: number;
    Longitude: number;
}
export interface ExclusiveZoneType {
    Boundaries: BoundaryType[];
}
export interface LineType {
    Points: PointType[];
}
export interface ResolutionAndCoordinateSystemType {
    Description?: string;
    GeodeticModel?: GeodeticModelType;
    HorizontalDataResolution?: HorizontalDataResolutionType;
    LocalCoordinateSystem?: LocalCoordinateSystemType;
}
export interface GeodeticModelType {
    DenominatorOfFlatteningRatio?: number;
    EllipsoidName?: string;
    HorizontalDatumName?: string;
    SemiMajorAxis?: number;
}
export interface HorizontalDataResolutionType {
    GenericResolutions?: HorizontalDataGenericResolutionType[];
    GriddedRangeResolutions?: HorizontalDataResolutionGriddedRangeType[];
    GriddedResolutions?: HorizontalDataResolutionGriddedType[];
    NonGriddedRangeResolutions?: HorizontalDataResolutionNonGriddedRangeType[];
    NonGriddedResolutions?: HorizontalDataResolutionNonGriddedType[];
    PointResolution?: HorizontalDataResolutionPointType;
    VariesResolution?: HorizontalDataResolutionVariesType;
}
export interface HorizontalDataGenericResolutionType {
    Unit: HorizontalDataResolutionUnitEnum;
    XDimension?: number;
    YDimension?: number;
}
export declare enum HorizontalDataResolutionUnitEnum {
    DecimalDegrees = "Decimal Degrees",
    Kilometers = "Kilometers",
    Meters = "Meters",
    NauticalMiles = "Nautical Miles",
    NotProvided = "Not provided",
    StatuteMiles = "Statute Miles"
}
export interface HorizontalDataResolutionGriddedRangeType {
    MaximumXDimension?: number;
    MaximumYDimension?: number;
    MinimumXDimension?: number;
    MinimumYDimension?: number;
    Unit: HorizontalDataResolutionUnitEnum;
}
export interface HorizontalDataResolutionGriddedType {
    Unit: HorizontalDataResolutionUnitEnum;
    XDimension?: number;
    YDimension?: number;
}
export interface HorizontalDataResolutionNonGriddedRangeType {
    MaximumXDimension?: number;
    MaximumYDimension?: number;
    MinimumXDimension?: number;
    MinimumYDimension?: number;
    ScanDirection?: HorizontalResolutionScanDirectionType;
    Unit: HorizontalDataResolutionUnitEnum;
    ViewingAngleType?: HorizontalResolutionViewingAngleType;
}
export declare enum HorizontalResolutionScanDirectionType {
    AlongTrack = "Along Track",
    CrossTrack = "Cross Track"
}
export declare enum HorizontalResolutionViewingAngleType {
    AtNadir = "At Nadir",
    ScanExtremes = "Scan Extremes"
}
export interface HorizontalDataResolutionNonGriddedType {
    ScanDirection?: HorizontalResolutionScanDirectionType;
    Unit: HorizontalDataResolutionUnitEnum;
    ViewingAngleType?: HorizontalResolutionViewingAngleType;
    XDimension?: number;
    YDimension?: number;
}
export declare enum HorizontalDataResolutionPointType {
    Point = "Point"
}
export declare enum HorizontalDataResolutionVariesType {
    Varies = "Varies"
}
export interface LocalCoordinateSystemType {
    Description?: string;
    GeoReferenceInformation?: string;
}
export interface OrbitParametersType {
    InclinationAngle: number;
    InclinationAngleUnit: EUnit;
    NumberOfOrbits: number;
    OrbitPeriod: number;
    OrbitPeriodUnit: OrbitPeriodUnit;
    StartCircularLatitude?: number;
    StartCircularLatitudeUnit?: EUnit;
    SwathWidth?: number;
    SwathWidthUnit?: FootprintUnit;
    Footprints?: FootprintType[];
}
export interface FootprintType {
    Description?: string;
    Footprint: number;
    FootprintUnit: FootprintUnit;
}
export declare enum FootprintUnit {
    Kilometer = "Kilometer",
    Meter = "Meter"
}
export declare enum EUnit {
    Degree = "Degree"
}
export declare enum OrbitPeriodUnit {
    DecimalMinute = "Decimal Minute"
}
export declare enum SpatialCoverageTypeEnum {
    EarthGlobal = "EARTH/GLOBAL",
    Horizontal = "HORIZONTAL",
    HorizontalOrbital = "HORIZONTAL_ORBITAL",
    HorizontalVertical = "HORIZONTAL_VERTICAL",
    HorizontalVerticalOrbital = "HORIZONTAL_VERTICAL_ORBITAL",
    Lunar = "LUNAR",
    Orbital = "ORBITAL",
    OrbitalVertical = "ORBITAL_VERTICAL",
    Vertical = "VERTICAL"
}
export interface VerticalSpatialDomainType {
    Type: VerticalSpatialDomainTypeEnum;
    Value: string;
}
export declare enum VerticalSpatialDomainTypeEnum {
    AtmosphereLayer = "Atmosphere Layer",
    MaximumAltitude = "Maximum Altitude",
    MaximumDepth = "Maximum Depth",
    MinimumAltitude = "Minimum Altitude",
    MinimumDepth = "Minimum Depth"
}
export interface SpatialInformationType {
    SpatialCoverageType: string;
    VerticalCoordinateSystem?: VerticalCoordinateSystemType;
}
export interface VerticalCoordinateSystemType {
    AltitudeSystemDefinition?: AltitudeSystemDefinitionType;
    DepthSystemDefinition?: DepthSystemDefinitionType;
}
export interface AltitudeSystemDefinitionType {
    DatumName?: string;
    DistanceUnits?: AltitudeDistanceUnitsEnum;
    Resolutions?: number[];
}
export declare enum AltitudeDistanceUnitsEnum {
    HectoPascals = "HectoPascals",
    Kilometers = "Kilometers",
    Millibars = "Millibars"
}
export interface DepthSystemDefinitionType {
    DatumName?: string;
    DistanceUnits?: DepthDistanceUnitsEnum;
    Resolutions?: number[];
}
export declare enum DepthDistanceUnitsEnum {
    Fathoms = "Fathoms",
    Feet = "Feet",
    HectoPascals = "HectoPascals",
    Meters = "Meters",
    Millibars = "Millibars"
}
export interface TemporalExtentType {
    EndsAtPresentFlag?: boolean;
    PeriodicDateTimes?: PeriodicDateTimeType[];
    PrecisionOfSeconds?: number;
    RangeDateTimes?: RangeDateTimeType[];
    SingleDateTimes?: Date[];
    TemporalResolution?: TemporalResolutionType;
}
export interface PeriodicDateTimeType {
    DurationUnit: DurationUnitEnum;
    DurationValue: number;
    EndDate: Date;
    Name: string;
    PeriodCycleDurationUnit: DurationUnitEnum;
    PeriodCycleDurationValue: number;
    StartDate: Date;
}
export declare enum DurationUnitEnum {
    Day = "DAY",
    Month = "MONTH",
    Year = "YEAR"
}
export interface RangeDateTimeType {
    BeginningDateTime: Date;
    EndingDateTime?: Date;
}
export interface TemporalResolutionType {
    Unit: TemporalResolutionTypeUnit;
    Value?: number;
}
export declare enum TemporalResolutionTypeUnit {
    Constant = "Constant",
    Day = "Day",
    Diurnal = "Diurnal",
    Hour = "Hour",
    Minute = "Minute",
    Month = "Month",
    Second = "Second",
    Varies = "Varies",
    Week = "Week",
    Year = "Year"
}
export interface TilingIdentificationSystemType {
    Coordinate1: TilingCoordinateType;
    Coordinate2: TilingCoordinateType;
    TilingIdentificationSystemName: TilingIdentificationSystemName;
}
export interface TilingCoordinateType {
    MaximumValue?: number | string;
    MinimumValue?: number | string;
}
export declare enum TilingIdentificationSystemName {
    Calipso = "CALIPSO",
    MODISTileEASE = "MODIS Tile EASE",
    MODISTileSIN = "MODIS Tile SIN",
    MilitaryGridReferenceSystem = "Military Grid Reference System",
    Misr = "MISR",
    WELDAlaskaTile = "WELD Alaska Tile",
    WELDCONUSTile = "WELD CONUS Tile",
    Wrs1 = "WRS-1",
    Wrs2 = "WRS-2"
}
export interface UseConstraintsType {
    Description?: string;
    EULAIdentifiers?: string[];
    FreeAndOpenData?: boolean;
    LicenseURL?: OnlineResourceType;
    LicenseText?: string;
}
export declare class Convert {
    static toUmmC(json: string): UmmC;
    static ummCToJson(value: UmmC): string;
}