Jibo-Revival-Group/Zos
8
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat: Add Be and tbd skill, also added Roadmap file

Browse Source
This commit is contained in:
Zane V
2026-05-10 16:32:12 -04:00
parent 3500ade13f
commit 0bb8885802
29587 changed files with 10611695 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
Skills/@be/node_modules/jibo-data-utils/lib/dts/index.d.ts generated vendored Normal file
View File

@@ -0,0 +1,8 @@
import { Log } from 'jibo-log';
export { default as Timezone, TimezoneJSON } from './location/Timezone';
export { default as DateTime, LocalTime, ToStringOptions as DateTimeToStringOptions } from './time/DateTime';
export { default as DateTimeUtils } from './time/DateTimeUtils';
export { default as Location, LocationJSON, setHome } from './location/Location';
export { default as LatLong } from './location/LatLong';
export { LocationUtils } from './location/LocationUtils';
export declare function initLog(parentLog: Log): void;

5
Skills/@be/node_modules/jibo-data-utils/lib/dts/location/LatLong.d.ts generated vendored Normal file
View File

@@ -0,0 +1,5 @@
interface LatLong {
lat: number;
lng: number;
}
export default LatLong;

170
Skills/@be/node_modules/jibo-data-utils/lib/dts/location/Location.d.ts generated vendored Normal file
View File

@@ -0,0 +1,170 @@
import LatLong from './LatLong';
import Timezone, { TimezoneJSON } from './Timezone';
/**
* @interface jibo.utils~LocationJSON
* @prop _type 'Location'
* @prop [city] {string}
* @prop [state] {string}
* @prop [stateAbbr] {string}
* @prop [country] {string}
* @prop [countryCode] {string}
* @prop lat {number}
* @prop lng {number}
* @prop [timezone] {jibo.utils~TimezoneJSON}
*/
export interface LocationJSON {
__type: 'Location';
city?: string;
state?: string;
stateAbbr?: string;
country?: string;
countryCode?: string;
lat: number;
lng: number;
timezone?: TimezoneJSON;
}
/**
* Class for handling locations - taking NLU inputs and turning them into full locations with
* a latitude and longitude, and optionally an attached timezone.
* @class Location
* @memberof jibo.utils
* @param {String} [city] The city for the location.
* @param {String} [state] The US state abbreviation for the location.
* @param {String} [country] The country for the location.
* @intdocs
*/
export default class Location {
/**
* The city name.
* @name jibo.utils.Location#city
* @type {String}
*/
city: string;
/**
* The state (or political equivalent) abbreviation, using the ISO_3166 1 alpha 2 spec (as best as Google gives it to us)
* @name jibo.utils.Location#stateAbbr
* @type {String}
*/
stateAbbr: string;
/**
* The state (or political equivalent) name.
* @name jibo.utils.Location#state
* @type {String}
*/
state: string;
/**
* The country name.
* @name jibo.utils.Location#country
* @type {String}
*/
country: string;
/**
* The country code, using the ISO_3166 1 alpha 2 spec (as best as Google gives it to us)
* @name jibo.utils.Location#countryCode
* @type {String}
*/
countryCode: string;
/**
* `true` if this location should make sure it has a timezone before returning from `fetch()`.
* @name jibo.utils.Location#needsTimezone
* @type {Boolean}
*/
needsTimezone: boolean;
/**
* The timezone that this location resides in.
* @name jibo.utils.Location#timezone
* @type {jibo.utils.Timezone}
*/
timezone: Timezone;
/**
* The latitude of this location. Negative values reflect latitudes south of the equator.
* @name jibo.utils.Location#lat
* @type {Number}
*/
lat: number;
/**
* The longitude of this location. Negative values reflect longitudes west of the Prime Meridian.
* @name jibo.utils.Location#lng
* @type {Number}
*/
lng: number;
/**
* Creates and returns a Location object. If no city, state, or country was supplied, returns
* Jibo's home location. All parameters are expected to be from the NLU parsing.
* @method jibo.utils.Location#create
* @param {String} [city] The city for the location.
* @param {String} [state] The US state abbreviation for the location.
* @param {String} [country] The country for the location.
* @static
*/
static create(city?: string, state?: string, country?: string): Location;
constructor(city?: string, state?: string, country?: string);
/**
* Jibo's home location
* @name jibo.utils.Location#jiboHome
* @type {Location}
* @static
* @readOnly
*/
static readonly jiboHome: Location;
/**
* `true` if this location is the same as Jibo's home.
* @name jibo.utils.Location#isLocal
* @type {Boolean}
* @readOnly
*/
readonly isLocal: boolean;
/**
* Completes missing location data and gets latitude and longitude.
* If `needsTimezone=true`, also gets the timezone. The callback takes `(error, {lat, lng})`.
* @method jibo.utils.Location#fetch
* @param {Function} callback The function to be called when the location has been fetched.
* @param {Boolean} [skipWA] `true` if a Wolfram Alpha query should be skipped. WA is only used to look up country capitals.
*/
fetch(callback: (error: any, latLng: LatLong) => void, skipWA?: boolean): void;
/**
* Checks to see if this location is in a given region, by comparing to countryCode or calculated regions (stateAbbr is combined with countryCode).
* @method jibo.utils.Location#isInRegion
* @param {string|string[]} regions The region or regions to compare to
* @return {Boolean} `true` if this location is in one of the compared regions
*/
isInRegion(regions: string | string[]): boolean;
/**
* Compares two Locations, by city, stateAbbr, and country.
* @method jibo.utils.Location#equals
* @param {Location} loc The Location to compare to this one.
* @return {Boolean} `true` if the two locations are the same
*/
equals(loc: any): boolean;
/**
* Gets the location name in a format suitable for insertion into TTS. If the location is local
* returns an empty string.
* @method jibo.utils.Location#getStandardName
* @return {String} The location name.
*/
getStandardName(): string;
/**
* Gets the location name in a format suitable for insertion into TTS, but prefixed with "In ".
* If the location is local returns an empty string.
* @method jibo.utils.Location#prefixIn
* @return {String} The location name.
*/
prefixIn(): string;
/**
* Gets the location name in a format suitable for visual display. US states are abbreviated.
* If in the same country as Jibo, the state will be used instead of the country. If in a
* different country, the state will be dropped.
* @method jibo.utils.Location#toString
* @return {String} The location name.
*/
toString(): string;
/**
* To be called by logging methods to have a more useful output.
* MIMs will call this if it is in the MIM prompt data.
* @method jibo.utils.Location#toLog
*/
toLog(): string;
toJSON(): LocationJSON;
private calculateRegions();
}
export declare function setHome(home: Location): void;

30
Skills/@be/node_modules/jibo-data-utils/lib/dts/location/LocationUtils.d.ts generated vendored Normal file
View File

@@ -0,0 +1,30 @@
/**
* State and capital
* @class LocationUtils
* @memberof jibo.utils
* @intdocs
*/
export declare class LocationUtils {
/**
* Sets the API key used for looking up country capitals
* @method jibo.utils.LocationUtils.setCapitalLookupKey
* @param {String} key Key used to enable lookups with the correct credentials
* @intdocs
*/
static setCapitalLookupKey(key: string): void;
/**
* Sets the API key used for looking up locations
* @method jibo.utils.LocationUtils.setLocationLookupKey
* @param {String} key Key used to enable lookups with the correct credentials
* @intdocs
*/
static setLocationLookupKey(key: string): void;
/**
* Gets the full name of a US state from its two letter abbreviation.
* @method jibo.utils.LocationUtils.getFullState
* @param {String} abbreviation The two letter US state abbreviation - LOWERCASE.
* @return {String} The full state name, or an empty string if it is not a US state.
* @intdocs
*/
static getFullState(abbreviation: string): string;
}

71
Skills/@be/node_modules/jibo-data-utils/lib/dts/location/Timezone.d.ts generated vendored Normal file
View File

@@ -0,0 +1,71 @@
import LatLong from '../location/LatLong';
/**
* @interface jibo.utils~TimezoneJSON
* @prop _type 'Timezone'
* @prop offsetUTC {number}
* @prop name {string}
* @prop id {string}
*/
export interface TimezoneJSON {
__type: 'Timezone';
offsetUTC: number;
name: string;
id: string;
}
/**
* A timezone, for date/time calculations.
* @class Timezone
* @memberof jibo.utils
* @param {Object} [serializedJSON] Output from a previous {@link jibo.utils.Timezone#toJSON} call.
*/
declare class Timezone {
/**
* Milliseconds by which the time is off from UTC, including active Daylight Savings Time
* @name jibo.utils.Timezone#offsetUTC
* @type {Number}
*/
offsetUTC: number;
/**
* Long name of timezone, like "Eastern Standard Time"
* @name jibo.utils.Timezone#name
* @type {string}
*/
name: string;
/**
* "tz" id of the timezone, like "America/Los_Angeles"
* @name jibo.utils.Timezone#id
* @type {string}
*/
id: string;
/**
* Sets the API key used for looking up locations
* @method jibo.utils.Timezone.setLocationLookupKey
* @param {String} key Key used to enable lookups with the correct credentials
* @intdocs
*/
static setLocationLookupKey(key: string): void;
static fromISOString(iso: string): Timezone;
constructor(serializedJSON?: any);
/**
* Fetches timezone information. The callback takes `(error, timezone)`.
* @method jibo.utils.Timezone#fetch
* @param {Object} location `{lat, lng}` object as output by {@link jibo.utils.Location#fetch}.
* @param {Function} callback The function to be called when the timezone has been fetched.
*/
fetch(location: LatLong, callback: (error: any, timezone: Timezone) => void): void;
toISOString(): string;
/**
* Serializes the Timezone into a JSON object with markers to assist in deserialization.
* @method jibo.utils.Timezone#toJSON
* @return {jibo.utils~TimezoneJSON} The serialized Timezone
*/
toJSON(): TimezoneJSON;
/**
* Creates request signatures per the requirements of Google Maps for Enterprise
* @param key The secret key used to create a signature for the provided request
* @param req The request to be signed
* @return {String} the signature for the provided request string and cryptographic key
*/
generateGoogleSignature(key: string, req: string): string;
}
export default Timezone;

332
Skills/@be/node_modules/jibo-data-utils/lib/dts/time/DateTime.d.ts generated vendored Normal file
View File

@@ -0,0 +1,332 @@
import Timezone, { TimezoneJSON } from '../location/Timezone';
export declare enum timePeriods {
YEAR = "year",
MONTH = "month",
WEEK = "week",
WEEKEND = "weekend",
DAY = "day",
MORNING = "morning",
AFTERNOON = "afternoon",
EVENING = "evening",
NIGHT = "night",
HOUR = "hour",
MINUTE = "minute",
NOW = "now",
}
/**
* @interface jibo.utils~ToStringOptions
* @description Options to be used when handling the string conversion of dates and times.
* @prop {boolean} [suppressVerbalOutput] If the `DateTime` should return
* an empty string for [toString()]{@link jibo.utils.DateTime#toString} and [prefixOnAt()]{@link jibo.utils.DateTime#prefixOnAt}.
* Allows greater control over how MIMs use the `DateTime` without the skill having to handle things
* specially.
* @prop {boolean} [dropPeriod] If the period (AM/PM) should be dropped from the time. Has no effect if the time would not
* be output.
* @prop {boolean} [display] `true` if the output should be display-compatible. Generally [toString()]{@link jibo.utils.DateTime#toString}
* should output display friendly strings, but some options may change that. To ensure that you get a
* display-compatible string, use this option.
* @prop {boolean} [prefixOnAt] Prefixes most days with 'On' and most times with 'at'.
* Examples: "On Tuesday", "At 3:00PM", "Tomorrow", "This morning".
* This replaces the use of [prefixOnAt()]{@link jibo.utils.DateTime#prefixOnAt}.
* @prop {boolean} [timeOnly] If only the time should be output, even if the date is not the
* current date.
* @prop {boolean} [dateOnly] If only the date/day should be output, even if it is the current day.
*/
export interface ToStringOptions {
suppressVerbalOutput?: boolean;
dropPeriod?: boolean;
display?: boolean;
prefixOnAt?: boolean;
timeOnly?: boolean;
dateOnly?: boolean;
}
/**
* @interface jibo.utils~LocalTime
* @prop {number} year YYYY
* @prop {string} month Full month name (i.e. `January`, `February`, ...)
* @prop {number} monthNum 0-11
* @prop {string} dayOfWeek Full weekday name (i.e. `Monday`, `Tuesday`, ...)
* @prop {number} date 1-31
* @prop {number} hour 0-23
* @prop {number} minute 0-59
* @prop {number} seconds 0-59
* @prop {number} milliseconds 0-999
*/
export interface LocalTime {
year: number;
month: string;
monthNum: number;
dayOfWeek: string;
date: number;
hour: number;
minute: number;
seconds: number;
milliseconds: number;
}
/**
* Interface describing the serialized form of a [DateTime]{@link jibo.utils.DateTime} instance.
* @interface jibo.utils~DateTimeJSON
* @prop {'DateTime'} _type Internal type field (for serializing and de-serializing).
* @prop {number} utc Milliseconds elapsed since January 1st 1970 UTC, like `Date.now()`.
* @prop {jibo.utils~TimezoneJSON} timezone Serialized form of [timezone]{@link jibo.utils.Timezone}.
* @prop {number} durationDays Duration of a time period in days, referring to weeks or weekends. Mutually exclusive with other durations.
* @prop {number} durationHours Duration of a time period in hours, referring to morning, afternoon, evening, or night.
* @prop {number} durationMinutes Duration of a time period in minutes, currently not used.
* @prop {string} timePeriod The original time period referenced by the input - a value from the [timePeriods]{@link jibo.utils.DateTime#timePeriods} enum.
*/
export interface DateTimeJSON {
__type: 'DateTime';
utc: number;
timezone: TimezoneJSON;
durationDays: number;
durationHours: number;
durationMinutes: number;
timePeriod: string;
}
/**
* Class for handling locations - taking NLU inputs and turning them into full locations with
* a latitude and longitude, and optionally an attached timezone.
* @class DateTime
* @memberof jibo.utils
* @param {string|Date|jibo.utils.Timezone} input Input from the NLU date/time factory.
* @param {Function} [input.getTime()] Required if `input` type = `Date`
* @param {jibo.utils.Timezone} [input.timezone] Required if `input` type = `DateTime`.
* @param {number} [input.durationDays] Required if `input` type = `DateTime`.
* @param {number} [input.durationHours] Required if `input` type = `DateTime`.
* @param {number} [input.durationMinutes] Required if `input` type = `DateTime`.
* @param {number} [input.timePeriod] Required if `input` type = `DateTime`.
* @param {String|jibo.utils.Timezone} nluTime Input from the NLU date/time factory
* @param {jibo.utils.Timezone} timezone Timezone that this date is in.
*/
declare class DateTime {
/**
* Duration of a time period in days, referring to weeks or weekends. Mutually exclusive
* with other durations.
* @name jibo.utils.DateTime#durationDays
* @type {Number}
* @readOnly
*/
durationDays: number;
/**
* Duration of a time period in hours, referring to morning, afternoon, evening, or night.
* @name jibo.utils.DateTime#durationHours
* @type {Number}
* @readOnly
*/
durationHours: number;
/**
* Duration of a time period in minutes, currently not used.
* @name jibo.utils.DateTime#durationMinutes
* @type {Number}
* @readOnly
*/
durationMinutes: number;
/**
* The original time period referenced by the input - a value from the [timePeriods]{@link jibo.utils.DateTime#timePeriods} enum.
* These values affect how the `DateTime` is converted into a string.
* @name jibo.utils.DateTime#timePeriod
* @type {String}
* @readOnly
*/
timePeriod: string;
/**
* Enum of the time periods.
* @name jibo.utils.DateTime#timePeriods
* @type {Object}
* @static
* @prop YEAR
* @prop MONTH
* @prop WEEK
* @prop WEEKEND
* @prop DAY
* @prop MORNING
* @prop AFTERNOON
* @prop EVENING
* @prop NIGHT
* @prop HOUR
* @prop MINUTE
* @prop NOW
*/
static readonly timePeriods: typeof timePeriods;
/**
* @method jibo.utils.DateTime#constructor
* @param {String} nluDay Input from the NLU date/time factory.
* @param {String} nluTime Input from the NLU date/time factory.
* @param {jibo.utils.Timezone} timezone Timezone that this date is in.
*/
constructor(nluDay?: string, nluTime?: string, timezone?: Timezone);
/**
* @method jibo.utils.DateTime#constructor
* @param {Object} serializedDateTime An object from [toJSON()]{@link jibo.utils.DateTime#toJSON} to deserialize.
*/
constructor(serializedDateTime: any);
/**
* @method jibo.utils.DateTime#constructor
* @param {Number} epochTime Milliseconds elapsed since January 1st 1970 UTC, like `Date.now()`.
* @param {jibo.utils.Timezone} timezone Timezone that this date is in.
*/
constructor(epochTime: number, timezone?: Timezone);
/**
* @method jibo.utils.DateTime#constructor
* @param {Date} date A standard Date object.
* @param {jibo.utils.Timezone} timezone Timezone that this date is in.
*/
constructor(date: Date, timezone?: Timezone);
/**
* Time in UTC. If this `DateTime` represents a period of time, then UTC is the start of it.
* @name jibo.utils.DateTime#utc
* @type {Number}
*/
utc: number;
/**
* The Timezone object that is the timezone that this `DateTime` exists in.
* @name jibo.utils.DateTime#timezone
* @type {jibo.utils.Timezone}
*/
timezone: Timezone;
/**
* Makes a copy of this `DateTime`, including a copy of the Timezone
* @method jibo.utils.DateTime#clone
* @return {DateTime} The `DateTime` clone.
*/
clone(): DateTime;
/**
* Changes this `DateTime` to the next section of the day - morning, afternoon, evening, night.
* @method jibo.utils.DateTime#jumpToNextDayPeriod
*/
jumpToNextDayPeriod(): void;
/**
* Adds a set number of years to the `DateTime`.
* @method jibo.utils.DateTime#addYear
* @param {Number} [years=1] The number of years to add.
*/
addYear(years?: number): void;
/**
* Adds a set number of days to the `DateTime` and changes it to a `DAY` time period.
* @method jibo.utils.DateTime#addDays
* @param {Number} days The number of days to add.
* @param {boolean} [zeroHours=false] If `true` will set hours/minutes/seconds to `0`.
*/
addDays(days: number, zeroHours?: boolean): void;
/**
* Adds a set number of hours to the `DateTime` and changes to an `HOUR` time period
* @method jibo.utils.DateTime#addHours
* @param {Number} hours The number of hours to add.
* @param {boolean} [zeroMinutes=false] If `true` will set minutes/seconds to `0`.
*/
addHours(hours: number, zeroMinutes?: boolean): void;
/**
* Sets the local time, with hours being in 24 hour time (0-23).
* Changes to an `HOUR` time period if no minutes were provided,
* or `MINUTE` time period if they were.
* @method jibo.utils.DateTime#setTime
* @param {number} hours Hour in 24 hour time to set the time to.
* @param {number} [minutes=0] Minutes to set the time to.
* @param {number} [seconds=0] Seconds to set the time to.
* @param {number} [milliseconds=0] milliseconds to set the time to.
*/
setTime(hours: number, minutes: number, seconds?: number, milliseconds?: number): void;
/**
* Irreversibly remove the time from this `DateTime`, turning it into just a full day.
* This has no effect on `DateTimes` that are already days, weekends, weeks, months, or years.
* @method jibo.utils.DateTime#stripTime
*/
stripTime(): void;
/**
* If this `DateTime` is in the past. Time periods are only in the past if the end of the period
* is in the past.
* @method jibo.utils.DateTime#isPast
* @return {Boolean} If the time period has ended and is thus fully in the past.
*/
isPast(): boolean;
/**
* If this `DateTime` is in the future (by any amount).
* @method jibo.utils.DateTime#isFuture
* @return {Boolean} If the time has not come to pass yet.
*/
isFuture(): boolean;
/**
* If this `DateTime` is within the specified date range
* @method jibo.utils.DateTime#isInRange
* @param {string} startDate The start date, in the format 'M/D' or 'M-D'
* @param {string} endDate The end date, in the format 'M/D' or 'M-D'
* @return {Boolean} If the time has not come to pass yet.
*/
isInRange(startDate: string, endDate: string): boolean;
/**
* Returns an object with separate properties for local time (in this `DateTime`'s timezone)
* If this `DateTime` refers to a time period, then the local time will be the start time of that
* time period
* @method jibo.utils.DateTime#getLocalTime
* @return {Object} The local time object.
*/
getLocalTime(): LocalTime;
/**
* Gets this date in `MMDD` format, useful for some web APIs.
* @method jibo.utils.DateTime#getLocalMMDD
* @return {String} The date.
*/
getLocalMMDD(): string;
/**
* Gets this date in `YYYYMMDD` format, useful for some web APIs.
* @method jibo.utils.DateTime#getLocalYYYYMMDD
* @return {String} The date.
*/
getLocalYYYYMMDD(): string;
/**
* Returns the number of days between this date and the current date.
* @method jibo.utils.DateTime#getRelativeDays
* @return {Number} The number of days.
*/
getRelativeDays(): number;
/**
* Returns the number of hours between this date/time and the current time.
* @method jibo.utils.DateTime#getRelativeHours
* @return {Number} The number of hours.
*/
getRelativeHours(): number;
/**
* Gets the local date/time (in this DateTime's timezone) as a human readable or Jibo speakable
* string.
* It is designed to output stuff like "Today", "3:00PM", "Tomorrow at 3:30PM", "Tuesday".
* If [ToStringOptions.suppressVerbalOutput]{@link jibo.utils~ToStringOptions} is `true`, then it returns an empty string.
* @method jibo.utils.DateTime#toString
* @param {jibo.utils~ToStringOptions} [options] Options to be used when handling the string conversion.
* @return {String} The verbal output.
*/
toString(options?: ToStringOptions): string;
/**
* @method jibo.utils.DateTime#prefixOnAt
* @deprecated
* @see jibo.utils~ToStringOptions
*/
prefixOnAt(options?: ToStringOptions): string;
/**
* Gets the relative time in a similar style to MomentJS, but simplified for display on Jibo's
* screen.
* Currently only supports past times.
* @method jibo.utils.DateTime#toMoment
* @return {String} The relative time output.
*/
toMoment(): string;
/**
* Serializes the `DateTime` into a JSON object with markers to assist in deserialization.
* @method jibo.utils.DateTime#toJSON
* @return {jibo.utils~DateTimeJSON} The serialized `DateTime`.
*/
toJSON(): DateTimeJSON;
/**
* Outputs an ISO formatted string. See
* [MDN web docs](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toISOString)
* @method jibo.utils.DateTime#toISOString
* @return {string}
*/
toISOString(): string;
/**
* To be called by logging methods to have a more useful output.
* MIMs will call this if it is in the MIM prompt data.
* @method jibo.utils.DateTime#toLog
*/
toLog(): DateTimeJSON;
}
export default DateTime;

111
Skills/@be/node_modules/jibo-data-utils/lib/dts/time/DateTimeUtils.d.ts generated vendored Normal file
View File

@@ -0,0 +1,111 @@
import DateTime from './DateTime';
/**
* Utilities for date and time.
* @class DateTimeUtils
* @memberof jibo.utils
*/
declare namespace DateTimeUtils {
/**
* Zero-based array of (lower-case) month names, starting with `january`.
* @name jibo.utils.DateTimeUtils.MONTHS
* @type {String[]}
*/
const MONTHS: string[];
/**
* Zero-based array of three-letter month abbreviations, starting with `Jan`.
* @name jibo.utils.DateTimeUtils.MONTH_ABBREVIATIONS
* @type {String[]}
*/
const MONTH_ABBREVIATIONS: string[];
/**
* Zero-based array of (lower-case) day names, starting with `sunday`.
* @name jibo.utils.DateTimeUtils.DAYS_OF_WEEK
* @type {String[]}
*/
const DAYS_OF_WEEK: string[];
/**
* Unit of time for getting the difference between two DateTimes
* @typedef jibo.utils.DateTimeUtils.DiffUnit
* @prop Milliseconds 0
* @prop Seconds 1
* @prop Minutes 2
* @prop Hours 3
* @prop Days 4
* @prop Weeks 5
*/
enum DiffUnit {
Milliseconds = 0,
Seconds = 1,
Minutes = 2,
Hours = 3,
Days = 4,
Weeks = 5,
}
/**
* Gets a verbal/written string of an integer value. Currently this function can only handle values
* between `-99` and `99`.
* @method jibo.utils.DateTimeUtils.getVerbalNumber
* @param {Number} input Integer to convert.
* @returns {String} Spoken version of the number.
*/
function getVerbalNumber(input: number): string;
/**
* Gets the [ordinal form]{@link https://en.wiktionary.org/wiki/ordinal_number} of a positive integer.
* @method jibo.utils.DateTimeUtils.getOrdinal
* @param {Number} num Integer to get the ordinal form of.
* @return {String} Ordinal number.
*/
function getOrdinal(num: number): string;
/**
* Gets a verbal string for Jibo to read from a time in 24-hour values.
* @method jibo.utils.DateTimeUtils.getVerbalTime
* @param {Number} hour Hour in 24-hour time.
* @param {Number} [minute=0] Minutes in the time.
* @param {Boolean} [dropPeriod=false] `true` if the period (AM/PM) should be dropped from the time.
* @returns {String} Verbal time, ie `three PM`.
*/
function getVerbalTime(hour: number, minute?: number, dropPeriod?: boolean): string;
/**
* Gets a string suitable for visual display of a time.
* @method jibo.utils.DateTimeUtils.getVisualTime
* @param {Number} hour The hour in 24-hour time.
* @param {Number|null} [minute=0] Minutes in the time. Pass null to drop minutes entirely (`3 PM`).
* @param {Boolean} [dropPeriod=false] `true` if the period (AM/PM) should be dropped from the time.
* @returns {String} Visual time, ie `3:00 PM`.
*/
function getVisualTime(hour: number, minute?: number, dropPeriod?: boolean): string;
/**
* Converts a 24-hour HHMM time string to a verbal 12-hour time for Jibo to read.
* @method jibo.utils.DateTimeUtils.getVerbalTimeFrom24Hour
* @param {String} time 24-hour time as a string, ie `1500`.
* @returns {String} Verbal time, ie `three PM`.
*/
function getVerbalTimeFrom24Hour(time: string): string;
/**
* Converts a 24-hour HHMM time string to 12-hour time for display.
* @method jibo.utils.DateTimeUtils.getVisualTimeFrom24Hour
* @param {String} time 24 hour time as a string, ie `1500`.
* @returns {String} Visual time, ie `3:00 PM`.
*/
function getVisualTimeFrom24Hour(time: string): string;
/**
* Gets the number of days between two dates, ignoring hours and minutes.
* @method jibo.utils.DateTimeUtils.getDaysBetweenDates
* @param {Date} a Earlier date.
* @param {Date} b Later date.
* @returns {Number} The number of days between the two dates.
*/
function getDaysBetweenDates(a: any, b: any): number;
/**
* Gets the amount of time between two DateTimes. Differences are not rounded. When getting
* the difference in days, this is not the difference in dates, but the difference in 24 hour
* segments.
* @method jibo.utils.DateTimeUtils.diffDateTimes
* @param {jibo.utils.DateTime} a Earlier date.
* @param {jibo.utils.DateTime} b Later date.
* @param {jibo.utils.DateTimeUtils.DiffUnit} [unit=DiffUnit.Milliseconds] Unit to get the difference in.
* @returns {Number} The difference between the two dates.
*/
function diffDateTimes(a: DateTime, b: DateTime, unit?: DiffUnit): number;
}
export default DateTimeUtils;