// Copyright 2007-2010 Panopto, Inc.
// All rights reserved.  Reuse and redistribution strictly prohibited.

/// <reference name="MicrosoftAjax.js"/>

Type.registerNamespace("Panopto.Data");


Panopto.Data.AclRoleType = function ()
{
    /// <summary>
    ///     enum Panopto.Data.AclRoleType
    ///     
    ///     NOTE: This must be kept in sync with Panopto.Data.AclRoleType,
    ///     defined in SharedLib/Constants.cs.
    ///     NOTE: AclRoleType.Service is omitted so it does not appear in the UI.
    /// </summary>
    ///
    /// <field name="Viewer" type="Number" />
    /// <field name="Creator" type="Number" />
    /// <field name="Admin" type="Number" />
    /// <field name="Videographer" type="Number" />
}

Panopto.Data.AclRoleType.prototype =
{
    Viewer:         1,
    Creator:        2,
    Admin:          3,
    Videographer:   4
};

Panopto.Data.AclRoleType.getName = function (value)
{
    ///	<summary>
    ///		Get the enum name for the specified value.</summary>
    ///	<param name="value" type="Number">
    ///		The value of the enum field.</param>
    ///	<returns type="String" />

    return Panopto.Data.AclRoleType._enumNames[value];
}

// Lookup table from enum value => name.
// Index in array must correspond to enum value above.
Panopto.Data.AclRoleType._enumNames = [];
for (enumName in Panopto.Data.AclRoleType.prototype)
{
    // Array index of enumName corresponds to its numerical value.
    Panopto.Data.AclRoleType._enumNames[Panopto.Data.AclRoleType.prototype[enumName]] = enumName;
}

Panopto.Data.AclRoleType.getDisplayName = function (role)
{
    ///	<summary>
    ///		Display a localized name for the specified role.</summary>
    ///	<param name="role" type="Panopto.Data.AclRoleType">
    ///		The status enum value to display.</param>
    ///	<returns type="String" />

    var roleName = Panopto.Data.AclRoleType.getName(role);

    // Return localized string, defaulting to non-localized version if not found.
    return Panopto.GlobalResources["AclRoleType_" + roleName] || role || Panopto.GlobalResources["AclRoleType_Viewer"];
}

// Register with MicrosoftAjax Type model after enum is defined.
Panopto.Data.AclRoleType.registerEnum("Panopto.Data.AclRoleType");


Panopto.Data.FolderColumns = function ()
{
    /// <summary>
    ///     enum Panopto.Data.FolderColumns
    ///     
    ///     NOTE: This must be kept in sync with Panopto.Data.DB.WebUI.FolderColumns, defined in
    ///     DataLib/LinqWrappers/WebUI/FolderRow.cs
    /// </summary>
    ///
    /// <field name="Name" />
    /// <field name="Presenters" />
    /// <field name="Sessions" />
    /// <field name="Relevance" />
    /// <field name="Site" />
}

Panopto.Data.FolderColumns.prototype =
{
    Name: 0,
    Presenters: 1,
    Sessions: 2,
    Relevance: 3,
    Site: 4
};

Panopto.Data.FolderColumns.getName = function (value)
{
    ///	<summary>
    ///		Get the enum name for the specified value.</summary>
    ///	<param name="value" type="Number">
    ///		The value of the enum field.</param>
    ///	<returns type="String" />

    return Panopto.Data.FolderColumns._enumNames[value];
}

// Lookup table from enum value => name.
// Index in array must correspond to enum value above.
Panopto.Data.FolderColumns._enumNames = [];
for (enumName in Panopto.Data.FolderColumns.prototype)
{
    // Array index of enumName corresponds to its numerical value.
    Panopto.Data.FolderColumns._enumNames[Panopto.Data.FolderColumns.prototype[enumName]] = enumName;
}

Panopto.Data.FolderColumns.getDisplayName = function (value)
{
    var enumName = Panopto.Data.FolderColumns.getName(value);

    // Return localized string, defaulting to non-localized version if not found.
    return Panopto.GlobalResources["FolderColumns_" + enumName] || enumName;
}

// Register with MicrosoftAjax Type model after enum is defined.
Panopto.Data.FolderColumns.registerEnum("Panopto.Data.FolderColumns");


Panopto.Data.UsageColumns = function ()
{
    /// <summary>
    ///     enum Panopto.Data.UsageColumns
    ///     
    ///     NOTE: This must be kept in sync with Panopto.Data.DB.WebUI.UsageColumns, defined in
    ///     DataLib/LinqWrappers/WebUI/UsageRow.cs
    /// </summary>
    ///
    /// <field name="Name" />
    /// <field name="Sessions" />
    /// <field name="HoursRecorded" />
    /// <field name="Views" />
    /// <field name="HoursViewed" />
    /// <field name="Storage" />
}

Panopto.Data.UsageColumns.prototype =
{
    Name: 0,
    Sessions: 1,
    HoursRecorded: 2,
    Views: 3,
    HoursViewed: 4,
    Storage: 5
};

Panopto.Data.UsageColumns.getName = function (value)
{
    ///	<summary>
    ///		Get the enum name for the specified value.</summary>
    ///	<param name="value" type="Number">
    ///		The value of the enum field.</param>
    ///	<returns type="String" />

    return Panopto.Data.UsageColumns._enumNames[value];
}

// Lookup table from enum value => name.
// Index in array must correspond to enum value above.
Panopto.Data.UsageColumns._enumNames = [];
for (enumName in Panopto.Data.UsageColumns.prototype)
{
    // Array index of enumName corresponds to its numerical value.
    Panopto.Data.UsageColumns._enumNames[Panopto.Data.UsageColumns.prototype[enumName]] = enumName;
}

Panopto.Data.UsageColumns.getDisplayName = function (value)
{
    var enumName = Panopto.Data.UsageColumns.getName(value);

    // Return localized string, defaulting to non-localized version if not found.
    return Panopto.GlobalResources["UsageColumns_" + enumName] || enumName;
}

// Register with MicrosoftAjax Type model after enum is defined.
Panopto.Data.UsageColumns.registerEnum("Panopto.Data.UsageColumns");


Panopto.Data.RemoteRecorderColumns = function ()
{
    /// <summary>
    ///     enum Panopto.Data.RemoteRecorderColumns
    ///     
    ///     NOTE: This must be kept in sync with Panopto.Data.DB.WebUI.RemoteRecorderColumns, defined in
    ///     DataLib/LinqWrappers/WebUI/RemoteRecorderRow.cs
    /// </summary>
    ///
    /// <field name="Name" />
    /// <field name="Status" />
    /// <field name="Session" />
    /// <field name="Date" />
    /// <field name="Site" />
}

Panopto.Data.RemoteRecorderColumns.prototype =
{
    Name: 0,
    Status: 1,
    Session: 2,
    Date: 3,
    Site: 4
};

Panopto.Data.RemoteRecorderColumns.getName = function (value)
{
    ///	<summary>
    ///		Get the enum name for the specified value.</summary>
    ///	<param name="value" type="Number">
    ///		The value of the enum field.</param>
    ///	<returns type="String" />

    return Panopto.Data.RemoteRecorderColumns._enumNames[value];
}

// Lookup table from enum value => name.
// Index in array must correspond to enum value above.
Panopto.Data.RemoteRecorderColumns._enumNames = [];
for (enumName in Panopto.Data.RemoteRecorderColumns.prototype)
{
    // Array index of enumName corresponds to its numerical value.
    Panopto.Data.RemoteRecorderColumns._enumNames[Panopto.Data.RemoteRecorderColumns.prototype[enumName]] = enumName;
}

Panopto.Data.RemoteRecorderColumns.getDisplayName = function (value)
{
    var enumName = Panopto.Data.RemoteRecorderColumns.getName(value);

    // Return localized string, defaulting to non-localized version if not found.
    return Panopto.GlobalResources["RemoteRecorderColumns_" + enumName] || enumName;
}

// Register with MicrosoftAjax Type model after enum is defined.
Panopto.Data.RemoteRecorderColumns.registerEnum("Panopto.Data.RemoteRecorderColumns");


Panopto.Data.SessionColumns = function ()
{
    /// <summary>
    ///     enum Panopto.Data.SessionColumns
    ///     
    ///     NOTE: This must be kept in sync with Panopto.Data.DB.WebUI.SessionColumns, defined in
    ///     DataLib/LinqWrappers/WebUI/SessionsRow.cs
    /// </summary>
    ///
    /// <field name="SessionName" />
    /// <field name="Date" />
    /// <field name="Duration" />
    /// <field name="Relevance" />
    /// <field name="Site" />
    /// <field name="Status" />
    /// <field name="RemoteRecorder" />
    /// <field name="Machine" />
}

Panopto.Data.SessionColumns.prototype =
{
    SessionName: 0,
    Date: 1,
    Duration: 2,
    Relevance: 3,
    Site: 4,
    Status: 5,
    RemoteRecorder: 6,
    Machine: 7
};

Panopto.Data.SessionColumns.getName = function (value)
{
    ///	<summary>
    ///		Get the enum name for the specified value.</summary>
    ///	<param name="value" type="Number">
    ///		The value of the enum field.</param>
    ///	<returns type="String" />

    return Panopto.Data.SessionColumns._enumNames[value];
}

// Lookup table from enum value => name.
// Index in array must correspond to enum value above.
Panopto.Data.SessionColumns._enumNames = [];
for (enumName in Panopto.Data.SessionColumns.prototype)
{
    // Array index of enumName corresponds to its numerical value.
    Panopto.Data.SessionColumns._enumNames[Panopto.Data.SessionColumns.prototype[enumName]] = enumName;
}

Panopto.Data.SessionColumns.getDisplayName = function (value)
{
    var enumName = Panopto.Data.SessionColumns.getName(value);

    // Return localized string, defaulting to non-localized version if not found.
    return Panopto.GlobalResources["SessionColumns_" + enumName] || enumName;
}

// Register with MicrosoftAjax Type model after enum is defined.
Panopto.Data.SessionColumns.registerEnum("Panopto.Data.SessionColumns");


Panopto.Data.RemoteRecorderStatus = function ()
{
    /// <summary>
    ///     enum Panopto.Data.RemoteRecorderStatus
    ///     
    ///     NOTE: This must be kept in sync with Panopto.Data.DB.WebUI.RemoteRecorderStatus,
    ///     defined in DataLib/LinqWrappers/WebUI/SessionsRow.cs, and RemoteRecorderStatus_*
    ///     resources.
    /// </summary>
    ///
    /// <field name="Error" />
    /// <field name="Disconnected" />
    /// <field name="Ready" />
    /// <field name="InUse" />
}

Panopto.Data.RemoteRecorderStatus.prototype =
{
    Error: 0,
    Disconnected: 1,
    Ready: 2,
    InUse: 3
};

Panopto.Data.RemoteRecorderStatus.getName = function (value)
{
    ///	<summary>
    ///		Get the enum name for the specified value.</summary>
    ///	<param name="value" type="Number">
    ///		The value of the enum field.</param>
    ///	<returns type="String" />

    return Panopto.Data.RemoteRecorderStatus._enumNames[value];
}

// Lookup table from enum value => name.
// Index in array must correspond to enum value above.
Panopto.Data.RemoteRecorderStatus._enumNames = [];
for (enumName in Panopto.Data.RemoteRecorderStatus.prototype)
{
    // Array index of enumName corresponds to its numerical value.
    Panopto.Data.RemoteRecorderStatus._enumNames[Panopto.Data.RemoteRecorderStatus.prototype[enumName]] = enumName;
}

Panopto.Data.RemoteRecorderStatus.getDisplayName = function (status)
{
    ///	<summary>
    ///		Display a localized name for the specified status.</summary>
    ///	<param name="status" type="Panopto.Data.RemoteRecorderStatus">
    ///		The status enum value to display.</param>
    ///	<returns type="String" />

    var statusName = Panopto.Data.RemoteRecorderStatus.getName(status);

    // Return localized string, defaulting to non-localized version if not found.
    return Panopto.GlobalResources["RemoteRecorderStatus_" + statusName] || statusName;
}

// Register with MicrosoftAjax Type model after enum is defined.
Panopto.Data.RemoteRecorderStatus.registerEnum("Panopto.Data.RemoteRecorderStatus");


Panopto.Data.SessionStatus = function ()
{
    /// <summary>
    ///     enum Panopto.Data.SessionStatus
    ///     
    ///     NOTE: This must be kept in sync with Panopto.Data.DB.WebUI.SessionStatus,
    ///     defined in DataLib/LinqWrappers/WebUI/SessionsRow.cs, and SessionStatus_*
    ///     resources.
    /// </summary>
    ///
    /// <field name="Created" type="Number" />
    /// <field name="Scheduled" type="Number" />
    /// <field name="Recording" type="Number" />
    /// <field name="Processing" type="Number" />
    /// <field name="Complete" type="Number" />
    /// <field name="Live" type="Number" />
}

Panopto.Data.SessionStatus.prototype =
{
    Created: 0,
    Scheduled: 1,
    Recording: 2,
    Processing: 3,
    Complete: 4,
    Live: 5
};

Panopto.Data.SessionStatus.getName = function (value)
{
    ///	<summary>
    ///		Get the enum name for the specified value.</summary>
    ///	<param name="value" type="Number">
    ///		The value of the enum field.</param>
    ///	<returns type="String" />

    return Panopto.Data.SessionStatus._enumNames[value];
}

// Lookup table from enum value => name.
// Index in array must correspond to enum value above.
Panopto.Data.SessionStatus._enumNames = [];
for (enumName in Panopto.Data.SessionStatus.prototype)
{
    // Array index of enumName corresponds to its numerical value.
    Panopto.Data.SessionStatus._enumNames[Panopto.Data.SessionStatus.prototype[enumName]] = enumName;
}

Panopto.Data.SessionStatus.getDisplayName = function (status)
{
    ///	<summary>
    ///		Display a localized name for the specified status.</summary>
    ///	<param name="status" type="Panopto.Data.SessionStatus">
    ///		The status enum value to display.</param>
    ///	<returns type="String" />

    var statusName = Panopto.Data.SessionStatus.getName(status);

    // Return localized string, defaulting to non-localized version if not found.
    return Panopto.GlobalResources["SessionStatus_" + statusName] || statusName;
}

Panopto.Data.SessionStatus.getIcon = function (status)
{
    ///	<summary>
    ///		Returns an object with src, alt and title for the given status.
    ///	<param name="status" type="Panopto.Data.SessionStatus">
    ///		The status enum value to return an icon for.</param>
    ///	<returns type="object" />

    if (!Panopto.Data.SessionStatus._statusIcons)
    {
        var iconRoot = Panopto.cacheRoot + "/styles/Ocupop/images/";
        Panopto.Data.SessionStatus._statusIcons = new Array();

        Panopto.Data.SessionStatus._statusIcons[Panopto.Data.SessionStatus.Complete] =
            { src: iconRoot + "icon_play_session.png", title: Panopto.GlobalResources.SessionStatus_Complete };
        Panopto.Data.SessionStatus._statusIcons[Panopto.Data.SessionStatus.Created] =
            { src: iconRoot + "icon_created.png", title: Panopto.GlobalResources.SessionStatus_Created };
        Panopto.Data.SessionStatus._statusIcons[Panopto.Data.SessionStatus.Processing] =
            { src: iconRoot + "icon_processing.png", title: Panopto.GlobalResources.SessionStatus_Processing };
        Panopto.Data.SessionStatus._statusIcons[Panopto.Data.SessionStatus.Recording] =
            { src: iconRoot + "icon_recording.png", title: Panopto.GlobalResources.SessionStatus_Recording };
        Panopto.Data.SessionStatus._statusIcons[Panopto.Data.SessionStatus.Scheduled] =
            { src: iconRoot + "icon_scheduled.png", title: Panopto.GlobalResources.SessionStatus_Scheduled };
        Panopto.Data.SessionStatus._statusIcons[Panopto.Data.SessionStatus.Live] =
            { src: iconRoot + "icon_live.png", title: Panopto.GlobalResources.SessionStatus_Live };
    }

    return Panopto.Data.SessionStatus._statusIcons[status];
}

// Register with MicrosoftAjax Type model after enum is defined.
Panopto.Data.SessionStatus.registerEnum("Panopto.Data.SessionStatus");

// UI-level status sets for navbar, etc.
Panopto.Data.StatusSets =
{
    All: [Panopto.Data.SessionStatus.Complete, Panopto.Data.SessionStatus.Created, Panopto.Data.SessionStatus.Live, Panopto.Data.SessionStatus.Processing, Panopto.Data.SessionStatus.Recording, Panopto.Data.SessionStatus.Scheduled],
    InProgress: [Panopto.Data.SessionStatus.Recording, Panopto.Data.SessionStatus.Live],
    Processing: [Panopto.Data.SessionStatus.Processing],
    Scheduled: [Panopto.Data.SessionStatus.Scheduled]
};

Panopto.Data.ProcessingStatus = function ()
{
    /// <summary>
    ///     enum Panopto.Data.ProcessingStatus
    ///     
    ///     NOTE: This must be kept in sync with Panopto.Data.DB.WebUI.ProcessingStatus,
    ///     defined in DataLib/LinqWrappers/WebUI/SessionsRow.cs, and ProcessingStatus_*
    ///     resources.
    /// </summary>
    ///
    /// <field name="Error" type="Number" />
    /// <field name="Unhealthy" type="Number" />
    /// <field name="Healthy" type="Number" />
}

Panopto.Data.ProcessingStatus.prototype =
{
    Error: 0,
    Unhealthy: 1,
    Healthy: 2
};

Panopto.Data.ProcessingStatus.getName = function (value)
{
    ///	<summary>
    ///		Get the enum name for the specified value.</summary>
    ///	<param name="value" type="Number">
    ///		The value of the enum field.</param>
    ///	<returns type="String" />

    return Panopto.Data.ProcessingStatus._enumNames[value];
}

// Lookup table from enum value => name.
// Index in array must correspond to enum value above.
Panopto.Data.ProcessingStatus._enumNames = [];
for (enumName in Panopto.Data.ProcessingStatus.prototype)
{
    // Array index of enumName corresponds to its numerical value.
    Panopto.Data.ProcessingStatus._enumNames[Panopto.Data.ProcessingStatus.prototype[enumName]] = enumName;
}

Panopto.Data.ProcessingStatus.getDisplayName = function (status)
{
    ///	<summary>
    ///		Display a localized name for the specified status.</summary>
    ///	<param name="status" type="Panopto.Data.ProcessingStatus">
    ///		The status enum value to display.</param>
    ///	<returns type="String" />

    var statusName = Panopto.Data.ProcessingStatus.getName(status);

    // Return localized string, defaulting to non-localized version if not found.
    return Panopto.GlobalResources["ProcessingStatus_" + statusName] || statusName;
}

// Register with MicrosoftAjax Type model after enum is defined.
Panopto.Data.ProcessingStatus.registerEnum("Panopto.Data.ProcessingStatus");

Panopto.Data.UserColumns = function ()
{
    /// <summary>
    ///     enum Panopto.Data.UserColumns
    ///     
    ///     NOTE: This must be kept in sync with Panopto.Data.DB.WebUI.UserColumns,
    ///     defined in DataLib/LinqWrappers/WebUI/UserRow.cs, and UserColumns_*
    ///     resources.
    /// </summary>
    ///
    /// <field name="Username" type="Number" />
    /// <field name="Fullname" type="Number" />
    /// <field name="Email" type="Number" />
    /// <field name="Roles" type="Number" />
    /// <field name="LastLogin" type="Number" />
    /// <field name="DateAdded" type="Number" />
}

Panopto.Data.UserColumns.prototype =
{
    Username:   0,
    Fullname:   1,
    Email:      2,
    Roles:      3,
    LastLogin:  4,
    DateAdded:  5
};

Panopto.Data.UserColumns.getName = function (value)
{
    ///	<summary>
    ///		Get the enum name for the specified value.</summary>
    ///	<param name="value" type="Number">
    ///		The value of the enum field.</param>
    ///	<returns type="String" />

    return Panopto.Data.UserColumns._enumNames[value];
}

// Lookup table from enum value => name.
// Index in array must correspond to enum value above.
Panopto.Data.UserColumns._enumNames = [];
for (enumName in Panopto.Data.UserColumns.prototype)
{
    // Array index of enumName corresponds to its numerical value.
    Panopto.Data.UserColumns._enumNames[Panopto.Data.UserColumns.prototype[enumName]] = enumName;
}

Panopto.Data.UserColumns.getDisplayName = function (column)
{
    ///	<summary>
    ///		Display a localized name for the specified column.</summary>
    ///	<param name="column" type="Panopto.Data.UserColumns">
    ///		The status enum value to display.</param>
    ///	<returns type="String" />

    var columnName = Panopto.Data.UserColumns.getName(column);

    // Return localized string, defaulting to non-localized version if not found.
    return Panopto.GlobalResources["UserColumns_" + columnName] || columnName;
}

// Register with MicrosoftAjax Type model after enum is defined.
Panopto.Data.UserColumns.registerEnum("Panopto.Data.UserColumns");


Panopto.Data.ViewMode = function ()
{
    /// <summary>
    ///     enum Panopto.Data.ViewMode;
    /// </summary>
    /// <field name="List" />
    /// <field name="Details" />
}
Panopto.Data.ViewMode.prototype =
{
    List: 0,
    Details: 1
}
Panopto.Data.ViewMode.registerEnum("Panopto.Data.ViewMode");


Panopto.Data.LicenseColumns = function ()
{
    /// <summary>
    ///     enum Panopto.Data.LicenseColumns
    ///     
    ///     NOTE: This must be kept in sync with Panopto.Data.DB.WebUI.LicenseColumns,
    ///     defined in DataLib/LinqWrappers/WebUI/LicenseRow.cs, and LicenseColumns_*
    ///     resources.
    /// </summary>
    ///
    /// <field name="MachineName" type="Number" />
    /// <field name="MachineIp" type="Number" />
    /// <field name="LicenseStatus" type="Number" />
    /// <field name="LicenseType" type="Number" />
    /// <field name="LastLoginUser" type="Number" />
    /// <field name="LastLoginDate" type="Number" />
}

Panopto.Data.LicenseColumns.prototype =
{
    MachineName: 0,
    MachineIp: 1,
    LicenseStatus: 2,
    LicenseType: 3,
    LastLoginUser: 4,
    LastLoginDate: 5
};

Panopto.Data.LicenseColumns.getName = function (value)
{
    ///	<summary>
    ///		Get the enum name for the specified value.</summary>
    ///	<param name="value" type="Number">
    ///		The value of the enum field.</param>
    ///	<returns type="String" />

    return Panopto.Data.LicenseColumns._enumNames[value];
}

// Lookup table from enum value => name.
// Index in array must correspond to enum value above.
Panopto.Data.LicenseColumns._enumNames = [];
for (enumName in Panopto.Data.LicenseColumns.prototype)
{
    // Array index of enumName corresponds to its numerical value.
    Panopto.Data.LicenseColumns._enumNames[Panopto.Data.LicenseColumns.prototype[enumName]] = enumName;
}

Panopto.Data.LicenseColumns.getDisplayName = function (column)
{
    ///	<summary>
    ///		Display a localized name for the specified column.</summary>
    ///	<param name="column" type="Panopto.Data.LicenseColumns">
    ///		The status enum value to display.</param>
    ///	<returns type="String" />

    var columnName = Panopto.Data.LicenseColumns.getName(column);

    // Return localized string, defaulting to non-localized version if not found.
    return Panopto.GlobalResources["LicenseColumns_" + columnName] || columnName;
}

// Register with MicrosoftAjax Type model after enum is defined.
Panopto.Data.LicenseColumns.registerEnum("Panopto.Data.LicenseColumns");


Panopto.Data.MachineLicenseType = function ()
{
    /// <summary>
    ///     enum Panopto.Data.MachineLicenseType
    ///     
    ///     NOTE: This must be kept in sync with Panopto.Data.DB.WebUI.MachineLicenseType,
    ///     defined in DataLib/Server/Services/LicenseKey.cs, and MachineLicenseType_*
    ///     resources.
    /// </summary>
    ///
    /// <field name="Client" type="Number" />
    /// <field name="Server" type="Number" />
}

Panopto.Data.MachineLicenseType.prototype =
{
    Client: 0,
    Server: 1,
    Unison: 2
};

Panopto.Data.MachineLicenseType.getName = function (value)
{
    ///	<summary>
    ///		Get the enum name for the specified value.</summary>
    ///	<param name="value" type="Number">
    ///		The value of the enum field.</param>
    ///	<returns type="String" />

    return Panopto.Data.MachineLicenseType._enumNames[value];
}

// Lookup table from enum value => name.
// Index in array must correspond to enum value above.
Panopto.Data.MachineLicenseType._enumNames = [];
for (enumName in Panopto.Data.MachineLicenseType.prototype)
{
    // Array index of enumName corresponds to its numerical value.
    Panopto.Data.MachineLicenseType._enumNames[Panopto.Data.MachineLicenseType.prototype[enumName]] = enumName;
}

Panopto.Data.MachineLicenseType.getDisplayName = function (column)
{
    ///	<summary>
    ///		Display a localized name for the specified column.</summary>
    ///	<param name="column" type="Panopto.Data.MachineLicenseType">
    ///		The status enum value to display.</param>
    ///	<returns type="String" />

    var columnName = Panopto.Data.MachineLicenseType.getName(column);

    // Return localized string, defaulting to non-localized version if not found.
    return Panopto.GlobalResources["MachineLicenseType_" + columnName] || columnName;
}

// Register with MicrosoftAjax Type model after enum is defined.
Panopto.Data.MachineLicenseType.registerEnum("Panopto.Data.MachineLicenseType");


Panopto.Data.LicenseStatus = function ()
{
    /// <summary>
    ///     enum Panopto.Data.LicenseStatus
    ///     
    ///     NOTE: This must be kept in sync with Panopto.Data.DB.WebUI.LicenseStatus,
    ///     defined in DataLib/Server/Services/LicenseKey.cs, and LicenseStatus_*
    ///     resources.
    /// </summary>
    ///
    /// <field name="Unlicensed" type="Number" />
    /// <field name="Licensed" type="Number" />
    /// <field name="Deactivated" type="Number" />
}

Panopto.Data.LicenseStatus.prototype =
{
    Unlicensed: 0,
    Licensed: 1,
    Deactivated: 2
};

Panopto.Data.LicenseStatus.getName = function (value)
{
    ///	<summary>
    ///		Get the enum name for the specified value.</summary>
    ///	<param name="value" type="Number">
    ///		The value of the enum field.</param>
    ///	<returns type="String" />

    return Panopto.Data.LicenseStatus._enumNames[value];
}

// Lookup table from enum value => name.
// Index in array must correspond to enum value above.
Panopto.Data.LicenseStatus._enumNames = [];
for (enumName in Panopto.Data.LicenseStatus.prototype)
{
    // Array index of enumName corresponds to its numerical value.
    Panopto.Data.LicenseStatus._enumNames[Panopto.Data.LicenseStatus.prototype[enumName]] = enumName;
}

Panopto.Data.LicenseStatus.getDisplayName = function (column)
{
    ///	<summary>
    ///		Display a localized name for the specified column.</summary>
    ///	<param name="column" type="Panopto.Data.LicenseStatus">
    ///		The status enum value to display.</param>
    ///	<returns type="String" />

    var columnName = Panopto.Data.LicenseStatus.getName(column);

    // Return localized string, defaulting to non-localized version if not found.
    return Panopto.GlobalResources["LicenseStatus_" + columnName] || columnName;
}

// Register with MicrosoftAjax Type model after enum is defined.
Panopto.Data.LicenseStatus.registerEnum("Panopto.Data.LicenseStatus");


Panopto.Data.AclRowType = function ()
{
    /// <summary>
    ///     enum Panopto.Data.AclRowType
    ///     
    ///     NOTE: This must be kept in sync with Panopto.Data.DB.WebUI.AclRowType,
    ///     defined in DataLib/LinqWrappers/WebUI/AclData.cs, and AclRowType_*
    ///     resources.
    /// </summary>
    ///
    /// <field name="User" type="Number" />
    /// <field name="Group" type="Number" />
    /// <field name="Invite" type="Number" />
}

Panopto.Data.AclRowType.prototype =
{
    User: 0,
    Group: 1,
    Invite: 2
};

Panopto.Data.AclRowType.getName = function (value)
{
    ///	<summary>
    ///		Get the enum name for the specified value.</summary>
    ///	<param name="value" type="Number">
    ///		The value of the enum field.</param>
    ///	<returns type="String" />

    return Panopto.Data.AclRowType._enumNames[value];
}

// Lookup table from enum value => name.
// Index in array must correspond to enum value above.
Panopto.Data.AclRowType._enumNames = [];
for (enumName in Panopto.Data.AclRowType.prototype)
{
    // Array index of enumName corresponds to its numerical value.
    Panopto.Data.AclRowType._enumNames[Panopto.Data.AclRowType.prototype[enumName]] = enumName;
}

Panopto.Data.AclRowType.getDisplayName = function (type)
{
    ///	<summary>
    ///		Display a localized name for the specified ACL row type.</summary>
    ///	<param name="type" type="Panopto.Data.AclRowType">
    ///		The type enum value to display.</param>
    ///	<returns type="String" />

    var typeName = Panopto.Data.AclRowType.getName(type);

    // Return localized string, defaulting to non-localized version if not found.
    return Panopto.GlobalResources["AclRowType_" + typeName] || typeName;
}

Panopto.Data.AclRowType.getIcon = function (type)
{
    ///	<summary>
    ///		Returns an object with src, alt and title for the given type.
    ///	<param name="type" type="Panopto.Data.AclRowType">
    ///		The type enum value to return an icon for.</param>
    ///	<returns type="object" />

    if (!Panopto.Data.AclRowType._typeIcons)
    {
        var iconRoot = Panopto.cacheRoot + "/styles/Ocupop/images/";
        Panopto.Data.AclRowType._typeIcons = new Array();

        Panopto.Data.AclRowType._typeIcons[Panopto.Data.AclRowType.User] =
            { src: iconRoot + "icon_users.png", title: Panopto.GlobalResources.AclRowType_User };
        Panopto.Data.AclRowType._typeIcons[Panopto.Data.AclRowType.Group] =
            { src: iconRoot + "icon_share.png", title: Panopto.GlobalResources.AclRowType_Group };
        Panopto.Data.AclRowType._typeIcons[Panopto.Data.AclRowType.Invite] =
            { src: iconRoot + "icon_licenses.png", title: Panopto.GlobalResources.AclRowType_Invite };
    }

    return Panopto.Data.AclRowType._typeIcons[type];
}

// Register with MicrosoftAjax Type model after enum is defined.
Panopto.Data.AclRowType.registerEnum("Panopto.Data.AclRowType");


Panopto.Data.FolderSet = function ()
{
    /// <summary>
    ///     enum Panopto.Data.FolderSet
    /// </summary>
    ///
    /// <field name="MyFolders" type="Number" />
    /// <field name="SharedFolders" type="Number" />
    /// <field name="PublicFolders" type="Number" />
}

Panopto.Data.FolderSet.prototype =
{
    MyFolders: 1,
    SharedFolders: 2,
    PublicFolders: 4
};

Panopto.Data.FolderSet.registerEnum("Panopto.Data.FolderSet", true);


Panopto.Data.GroupType = function ()
{
    /// <summary>
    ///     enum Panopto.Data.GroupType
    ///     
    ///     NOTE: This must be kept in sync with Panopto.Data.GroupType,
    ///     defined in SharedLib/Constants.cs, and GroupType_* resources.
    /// </summary>
    ///
    /// <field name="ActiveDirectory" type="Number" />
    /// <field name="SsoGroup" type="Number" />
    /// <field name="Internal" type="Number" />
}

Panopto.Data.GroupType.prototype =
{
    ActiveDirectory: 1,
    SsoGroup: 2,
    Internal: 3
};

Panopto.Data.GroupType.getName = function (value)
{
    ///	<summary>
    ///		Get the enum name for the specified value.</summary>
    ///	<param name="value" type="Number">
    ///		The value of the enum field.</param>
    ///	<returns type="String" />

    return Panopto.Data.GroupType._enumNames[value];
}

// Lookup table from enum value => name.
// Index in array must correspond to enum value above.
Panopto.Data.GroupType._enumNames = [];
for (enumName in Panopto.Data.GroupType.prototype)
{
    // Array index of enumName corresponds to its numerical value.
    Panopto.Data.GroupType._enumNames[Panopto.Data.GroupType.prototype[enumName]] = enumName;
}

Panopto.Data.GroupType.getDisplayName = function (type)
{
    ///	<summary>
    ///		Display a localized name for the specified ACL row type.</summary>
    ///	<param name="type" type="Panopto.Data.GroupType">
    ///		The type enum value to display.</param>
    ///	<returns type="String" />

    var typeName = Panopto.Data.GroupType.getName(type);

    // Return localized string, defaulting to non-localized version if not found.
    return Panopto.GlobalResources["GroupType_" + typeName] || typeName;
}

// Register with MicrosoftAjax Type model after enum is defined.
Panopto.Data.GroupType.registerEnum("Panopto.Data.GroupType");