@instructure/platform-rubrics 0.2.0 → 0.4.0

package/dist/_internal/ViewRubrics/queries/gql.d.ts

@@ -0,0 +1,6 @@
+import { DocumentNode } from 'graphql';
+export declare const VIEW_RUBRICS_COURSE_RUBRICS_QUERY: DocumentNode;
+export declare const VIEW_RUBRICS_ACCOUNT_RUBRICS_QUERY: DocumentNode;
+export declare const VIEW_RUBRICS_PREVIEW_QUERY: DocumentNode;
+export declare const VIEW_RUBRICS_UPDATE_ARCHIVED_STATE: DocumentNode;
+//# sourceMappingURL=gql.d.ts.map

package/dist/_internal/ViewRubrics/queries/gql.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gql.d.ts","sourceRoot":"","sources":["../../../../src/_internal/ViewRubrics/queries/gql.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,SAAS,CAAA;AAwC3C,eAAO,MAAM,iCAAiC,EAAE,YAsB/C,CAAA;AAED,eAAO,MAAM,kCAAkC,EAAE,YAsBhD,CAAA;AAED,eAAO,MAAM,0BAA0B,EAAE,YA+BxC,CAAA;AAED,eAAO,MAAM,kCAAkC,EAAE,YAahD,CAAA"}

package/dist/_internal/ViewRubrics/queries/mutations.d.ts

@@ -0,0 +1,40 @@
+import { Rubric, RubricCriterion, RubricImport } from '../../types/rubric';
+import { UsedLocation } from '../types';
+export type DeleteRubricQueryResponse = Pick<Rubric, 'id' | 'title' | 'criteria' | 'hidePoints' | 'pointsPossible'>;
+export type DuplicateRubricQueryResponse = DeleteRubricQueryResponse;
+type DeleteRubricProps = {
+    id?: string;
+    accountId?: string;
+    courseId?: string;
+};
+export declare const deleteRubric: ({ id, accountId, courseId, }: DeleteRubricProps) => Promise<DeleteRubricQueryResponse>;
+type DuplicateRubricProps = {
+    id?: string;
+    accountId?: string;
+    courseId?: string;
+    title: string;
+    hidePoints?: boolean;
+    freeFormCriterionComments?: boolean;
+    criteria?: RubricCriterion[];
+    buttonDisplay?: string;
+    ratingOrder?: string;
+    workflowState?: string;
+};
+export declare const duplicateRubric: ({ title, hidePoints, freeFormCriterionComments, accountId, courseId, criteria, ratingOrder, buttonDisplay, workflowState, }: DuplicateRubricProps) => Promise<DuplicateRubricQueryResponse>;
+type FetchRubricUsedLocationsParams = {
+    accountId?: string;
+    courseId?: string;
+    id?: string;
+    nextPagePath?: string;
+};
+export declare const fetchRubricUsedLocations: ({ accountId, courseId, id, nextPagePath, }: FetchRubricUsedLocationsParams) => Promise<{
+    usedLocations: UsedLocation[];
+    isLastPage: boolean;
+    nextPage: string | undefined;
+}>;
+export declare const importRubric: (file: File | undefined, accountId: string | undefined, courseId: string | undefined) => Promise<RubricImport>;
+export declare const fetchRubricImport: (importId: string | undefined, accountId: string | undefined, courseId: string | undefined) => Promise<RubricImport>;
+export declare const getImportedRubrics: (importId: string, accountId: string | undefined, courseId: string | undefined) => Promise<Rubric[]>;
+export declare const downloadRubrics: (courseId: string | undefined, accountId: string | undefined, selectedRubricIds: string[]) => Promise<void>;
+export {};
+//# sourceMappingURL=mutations.d.ts.map

package/dist/_internal/ViewRubrics/queries/mutations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mutations.d.ts","sourceRoot":"","sources":["../../../../src/_internal/ViewRubrics/queries/mutations.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,MAAM,EAAE,eAAe,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAA;AAE/E,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,UAAU,CAAA;AAiC5C,MAAM,MAAM,yBAAyB,GAAG,IAAI,CAC1C,MAAM,EACN,IAAI,GAAG,OAAO,GAAG,UAAU,GAAG,YAAY,GAAG,gBAAgB,CAC9D,CAAA;AACD,MAAM,MAAM,4BAA4B,GAAG,yBAAyB,CAAA;AA0BpE,KAAK,iBAAiB,GAAG;IACvB,EAAE,CAAC,EAAE,MAAM,CAAA;IACX,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,QAAQ,CAAC,EAAE,MAAM,CAAA;CAClB,CAAA;AAED,eAAO,MAAM,YAAY,GAAU,8BAIhC,iBAAiB,KAAG,OAAO,CAAC,yBAAyB,CAkBvD,CAAA;AAED,KAAK,oBAAoB,GAAG;IAC1B,EAAE,CAAC,EAAE,MAAM,CAAA;IACX,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,KAAK,EAAE,MAAM,CAAA;IACb,UAAU,CAAC,EAAE,OAAO,CAAA;IACpB,yBAAyB,CAAC,EAAE,OAAO,CAAA;IACnC,QAAQ,CAAC,EAAE,eAAe,EAAE,CAAA;IAC5B,aAAa,CAAC,EAAE,MAAM,CAAA;IACtB,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,aAAa,CAAC,EAAE,MAAM,CAAA;CACvB,CAAA;AAED,eAAO,MAAM,eAAe,GAAU,6HAUnC,oBAAoB,KAAG,OAAO,CAAC,4BAA4B,CA0D7D,CAAA;AAiBD,KAAK,8BAA8B,GAAG;IACpC,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,EAAE,CAAC,EAAE,MAAM,CAAA;IACX,YAAY,CAAC,EAAE,MAAM,CAAA;CACtB,CAAA;AAED,eAAO,MAAM,wBAAwB,GAAU,4CAK5C,8BAA8B,KAAG,OAAO,CAAC;IAC1C,aAAa,EAAE,YAAY,EAAE,CAAA;IAC7B,UAAU,EAAE,OAAO,CAAA;IACnB,QAAQ,EAAE,MAAM,GAAG,SAAS,CAAA;CAC7B,CA4BA,CAAA;AA0BD,eAAO,MAAM,YAAY,GACvB,MAAM,IAAI,GAAG,SAAS,EACtB,WAAW,MAAM,GAAG,SAAS,EAC7B,UAAU,MAAM,GAAG,SAAS,KAC3B,OAAO,CAAC,YAAY,CAatB,CAAA;AAED,eAAO,MAAM,iBAAiB,GAC5B,UAAU,MAAM,GAAG,SAAS,EAC5B,WAAW,MAAM,GAAG,SAAS,EAC7B,UAAU,MAAM,GAAG,SAAS,KAC3B,OAAO,CAAC,YAAY,CAMtB,CAAA;AAwBD,eAAO,MAAM,kBAAkB,GAC7B,UAAU,MAAM,EAChB,WAAW,MAAM,GAAG,SAAS,EAC7B,UAAU,MAAM,GAAG,SAAS,KAC3B,OAAO,CAAC,MAAM,EAAE,CA2BlB,CAAA;AAID,eAAO,MAAM,eAAe,GAC1B,UAAU,MAAM,GAAG,SAAS,EAC5B,WAAW,MAAM,GAAG,SAAS,EAC7B,mBAAmB,MAAM,EAAE,KAC1B,OAAO,CAAC,IAAI,CAiCd,CAAA"}

package/dist/_internal/ViewRubrics/queries/queries.d.ts

@@ -0,0 +1,29 @@
+import { ViewRubricsCourseRubricsQueryQuery } from '@instructure/platform-graphql-types';
+import { Rubric } from '../../types/rubric';
+import { ArchiveRubricResponse } from '../types';
+type ExecuteQuery = <TResult, TVariables = Record<string, unknown>>(query: unknown, variables: TVariables) => Promise<TResult>;
+export declare const RUBRICS_PER_PAGE = 50;
+export type RubricSortField = 'title' | 'criteria_count' | 'has_rubric_associations' | 'points_possible';
+export type RubricSortDirection = 'ascending' | 'descending';
+export type RubricSortInput = {
+    field: RubricSortField;
+    direction: RubricSortDirection;
+};
+export type RubricFetchOptions = {
+    first: number;
+    after: string | null;
+    searchTerm?: string;
+    sort?: RubricSortInput;
+    workflowStates?: string[];
+};
+export type RubricQueryResponse = NonNullable<NonNullable<ViewRubricsCourseRubricsQueryQuery['course']>['rubricsConnection']>;
+export type RubricQueryResponseNode = Exclude<NonNullable<RubricQueryResponse['nodes']>[number], null>;
+export declare const mapRubricConnectionNodeToRubric: (node: RubricQueryResponseNode) => Rubric;
+export declare const fetchCourseRubrics: (executeQuery: ExecuteQuery, courseId: string, options: RubricFetchOptions) => Promise<RubricQueryResponse | null>;
+export declare const fetchAccountRubrics: (executeQuery: ExecuteQuery, accountId: string, options: RubricFetchOptions) => Promise<RubricQueryResponse | null>;
+export type RubricPreviewResponse = Pick<Rubric, 'criteria' | 'title' | 'ratingOrder' | 'freeFormCriterionComments' | 'pointsPossible' | 'hidePoints' | 'buttonDisplay'>;
+export declare const fetchRubricCriterion: (executeQuery: ExecuteQuery, id?: string) => Promise<RubricPreviewResponse | null>;
+export declare const archiveRubric: (executeQuery: ExecuteQuery, rubricId: string) => Promise<ArchiveRubricResponse | null>;
+export declare const unarchiveRubric: (executeQuery: ExecuteQuery, rubricId: string) => Promise<ArchiveRubricResponse | null>;
+export {};
+//# sourceMappingURL=queries.d.ts.map

package/dist/_internal/ViewRubrics/queries/queries.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"queries.d.ts","sourceRoot":"","sources":["../../../../src/_internal/ViewRubrics/queries/queries.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAEV,kCAAkC,EAEnC,MAAM,qCAAqC,CAAA;AAC5C,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAA;AAChD,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,UAAU,CAAA;AAQrD,KAAK,YAAY,GAAG,CAAC,OAAO,EAAE,UAAU,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAChE,KAAK,EAAE,OAAO,EACd,SAAS,EAAE,UAAU,KAClB,OAAO,CAAC,OAAO,CAAC,CAAA;AAErB,eAAO,MAAM,gBAAgB,KAAK,CAAA;AAElC,MAAM,MAAM,eAAe,GACvB,OAAO,GACP,gBAAgB,GAChB,yBAAyB,GACzB,iBAAiB,CAAA;AAErB,MAAM,MAAM,mBAAmB,GAAG,WAAW,GAAG,YAAY,CAAA;AAE5D,MAAM,MAAM,eAAe,GAAG;IAC5B,KAAK,EAAE,eAAe,CAAA;IACtB,SAAS,EAAE,mBAAmB,CAAA;CAC/B,CAAA;AAED,MAAM,MAAM,kBAAkB,GAAG;IAC/B,KAAK,EAAE,MAAM,CAAA;IACb,KAAK,EAAE,MAAM,GAAG,IAAI,CAAA;IACpB,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,IAAI,CAAC,EAAE,eAAe,CAAA;IACtB,cAAc,CAAC,EAAE,MAAM,EAAE,CAAA;CAC1B,CAAA;AAED,MAAM,MAAM,mBAAmB,GAAG,WAAW,CAC3C,WAAW,CAAC,kCAAkC,CAAC,QAAQ,CAAC,CAAC,CAAC,mBAAmB,CAAC,CAC/E,CAAA;AACD,MAAM,MAAM,uBAAuB,GAAG,OAAO,CAC3C,WAAW,CAAC,mBAAmB,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,EACjD,IAAI,CACL,CAAA;AAED,eAAO,MAAM,+BAA+B,GAAI,MAAM,uBAAuB,KAAG,MA0B9E,CAAA;AAEF,eAAO,MAAM,kBAAkB,GAC7B,cAAc,YAAY,EAC1B,UAAU,MAAM,EAChB,SAAS,kBAAkB,KAC1B,OAAO,CAAC,mBAAmB,GAAG,IAAI,CAMpC,CAAA;AAED,eAAO,MAAM,mBAAmB,GAC9B,cAAc,YAAY,EAC1B,WAAW,MAAM,EACjB,SAAS,kBAAkB,KAC1B,OAAO,CAAC,mBAAmB,GAAG,IAAI,CAMpC,CAAA;AAED,MAAM,MAAM,qBAAqB,GAAG,IAAI,CACtC,MAAM,EACJ,UAAU,GACV,OAAO,GACP,aAAa,GACb,2BAA2B,GAC3B,gBAAgB,GAChB,YAAY,GACZ,eAAe,CAClB,CAAA;AAMD,eAAO,MAAM,oBAAoB,GAAU,cAAc,YAAY,EAAE,KAAK,MAAM,0CAOjF,CAAA;AAED,eAAO,MAAM,aAAa,GACxB,cAAc,YAAY,EAC1B,UAAU,MAAM,KACf,OAAO,CAAC,qBAAqB,GAAG,IAAI,CAMtC,CAAA;AAED,eAAO,MAAM,eAAe,GAC1B,cAAc,YAAY,EAC1B,UAAU,MAAM,KACf,OAAO,CAAC,qBAAqB,GAAG,IAAI,CAMtC,CAAA"}

package/dist/_internal/ViewRubrics/types.d.ts

@@ -0,0 +1,17 @@
+export type ArchiveRubricResponse = {
+    _id: string;
+    workflowState: string;
+};
+export type UsedLocation = {
+    id: string;
+    name: string;
+    concluded?: boolean;
+    assignments: {
+        id: string;
+        title: string;
+    }[];
+    withAssignments?: boolean;
+    assignmentsNextPage?: string;
+    assignmentsLastPage?: boolean;
+};
+//# sourceMappingURL=types.d.ts.map

package/dist/_internal/ViewRubrics/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/_internal/ViewRubrics/types.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,qBAAqB,GAAG;IAClC,GAAG,EAAE,MAAM,CAAA;IACX,aAAa,EAAE,MAAM,CAAA;CACtB,CAAA;AAED,MAAM,MAAM,YAAY,GAAG;IACzB,EAAE,EAAE,MAAM,CAAA;IACV,IAAI,EAAE,MAAM,CAAA;IACZ,SAAS,CAAC,EAAE,OAAO,CAAA;IACnB,WAAW,EAAE;QACX,EAAE,EAAE,MAAM,CAAA;QACV,KAAK,EAAE,MAAM,CAAA;KACd,EAAE,CAAA;IACH,eAAe,CAAC,EAAE,OAAO,CAAA;IACzB,mBAAmB,CAAC,EAAE,MAAM,CAAA;IAC5B,mBAAmB,CAAC,EAAE,OAAO,CAAA;CAC9B,CAAA"}

package/dist/_internal/ViewRubrics/useDebouncedValue.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Returns a copy of `value` that only updates after `delayMs` has elapsed
+ * without further changes. Used to throttle search input before it drives a
+ * network query.
+ */
+export declare function useDebouncedValue<T>(value: T, delayMs: number): T;
+//# sourceMappingURL=useDebouncedValue.d.ts.map

package/dist/_internal/ViewRubrics/useDebouncedValue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useDebouncedValue.d.ts","sourceRoot":"","sources":["../../../src/_internal/ViewRubrics/useDebouncedValue.ts"],"names":[],"mappings":"AAoBA;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,OAAO,EAAE,MAAM,GAAG,CAAC,CASjE"}

package/dist/_internal/ViewRubrics/useRubricsQuery.d.ts

@@ -0,0 +1,52 @@
+import { InfiniteData } from '@tanstack/react-query';
+import { RubricSortInput } from './queries/queries';
+type UseRubricsQueryParams = {
+    selectedTab: string | undefined;
+    searchTerm: string;
+    sort: RubricSortInput;
+    workflowStates: string[];
+};
+export declare const useRubricsQuery: ({ selectedTab, searchTerm, sort, workflowStates, }: UseRubricsQueryParams) => {
+    rubrics: import('../..').Rubric[];
+    totalCount: number;
+    isFetching: boolean;
+    isFetchingNextPage: boolean;
+    hasNextPage: boolean;
+    fetchNextPage: (options?: import('@tanstack/react-query').FetchNextPageOptions) => Promise<import('@tanstack/react-query').InfiniteQueryObserverResult<InfiniteData<{
+        nodes?: Array<{
+            buttonDisplay: string;
+            criteriaCount: number;
+            hasRubricAssociations: boolean;
+            hidePoints?: boolean | null;
+            freeFormCriterionComments: boolean;
+            pointsPossible?: number | null;
+            ratingOrder: string;
+            title?: string | null;
+            workflowState: string;
+            id: string;
+            criteria: Array<{
+                points?: number | null;
+                longDescription?: string | null;
+                description?: string | null;
+                ignoreForScoring: boolean;
+                learningOutcomeId?: string | null;
+                criterionUseRange: boolean;
+                id: string;
+                ratings?: Array<{
+                    description: string;
+                    longDescription?: string | null;
+                    points: number;
+                    id: string;
+                }> | null;
+            }>;
+        } | null> | null;
+        pageInfo: {
+            hasNextPage: boolean;
+            endCursor?: string | null;
+            totalCount?: number | null;
+        };
+    } | null, string | null>, Error>>;
+    invalidate: () => Promise<void>;
+};
+export {};
+//# sourceMappingURL=useRubricsQuery.d.ts.map

package/dist/_internal/ViewRubrics/useRubricsQuery.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useRubricsQuery.d.ts","sourceRoot":"","sources":["../../../src/_internal/ViewRubrics/useRubricsQuery.ts"],"names":[],"mappings":"AACA,OAAO,EACL,KAAK,YAAY,EAIlB,MAAM,uBAAuB,CAAA;AAG9B,OAAO,EAGL,KAAK,eAAe,EAIrB,MAAM,mBAAmB,CAAA;AAE1B,KAAK,qBAAqB,GAAG;IAC3B,WAAW,EAAE,MAAM,GAAG,SAAS,CAAA;IAC/B,UAAU,EAAE,MAAM,CAAA;IAClB,IAAI,EAAE,eAAe,CAAA;IACrB,cAAc,EAAE,MAAM,EAAE,CAAA;CACzB,CAAA;AAED,eAAO,MAAM,eAAe,GAAI,oDAK7B,qBAAqB;;;;;;;;;;;sBAoEw/nV,CAAC;;0BAAoE,CAAC;;iBAA2C,CAAC;;;;sBAA4E,CAAC;+BAAgC,CAAC;2BAA4B,CAAC;;iCAA6D,CAAC;;;uBAAgE,CAAC;;mCAA8C,CAAC;;;;;;;;qBAAsH,CAAC;sBAA2B,CAAC;;;;CAD7kpV,CAAA"}

package/dist/_internal/constants/i18n.d.ts

@@ -1,4 +1,386 @@
 export declare const i18nKeys: {
+    readonly importFailuresModalFileListHeader: "The import failed for the following file(s):";
+    readonly importFailuresModalHeading: "Import Failed";
+    readonly importFailuresModalLabel: "Import Failures";
+    readonly importFailuresModalReasonHeader: "This import failure was due to the following:";
+    readonly importRubricError: "Error Importing rubric";
+    readonly importRubricNoneImported: "No rubrics were successfully imported";
+    readonly importRubricStarted: "Rubric import started. This may take a few seconds to complete.";
+    readonly importRubricStatusError: "Error retrieving import status";
+    readonly importRubricSuccess: {
+        readonly one: "%{count} rubric was successfully imported";
+        readonly other: "%{count} rubrics were successfully imported";
+    };
+    readonly importRubricTrayChooseFile: "Choose a file to upload";
+    readonly importRubricTrayDownloadTemplate: "Download Template";
+    readonly importRubricTrayDragFile: "Drag a file here, or";
+    readonly importRubricTrayHeading: "Import Rubrics";
+    readonly importRubricTrayLabel: "Import Rubrics Tray";
+    readonly importRubricTrayTemplateAlert: "This feature requires the use of our rubric template.";
+    readonly importRubricUnknownError: "Unknown error occurred";
+    readonly importTableCaption: "Table of Imports in Progress";
+    readonly importTableFileNameHeader: "File Name";
+    readonly importTableProgressLabel: "Loading completion";
+    readonly importTableSizeHeader: "Size";
+    readonly rubricAssignmentContainerAddError: "Failed to add rubric to assignment";
+    readonly rubricAssignmentContainerAddSuccess: "Rubric added to assignment";
+    readonly rubricAssignmentContainerCreateRubric: "Create Rubric";
+    readonly rubricAssignmentContainerDeleteRubric: "Delete Rubric";
+    readonly rubricAssignmentContainerEditRubric: "Edit Rubric";
+    readonly rubricAssignmentContainerFindRubric: "Find Rubric";
+    readonly rubricAssignmentContainerLoadError: "Failed to load rubric for this assignment";
+    readonly rubricAssignmentContainerPreviewRubric: "Preview Rubric";
+    readonly rubricAssignmentContainerReplaceRubric: "Replace Rubric";
+    readonly rubricAssignmentContainerUnlinkRubric: "Unlink Rubric";
+    readonly rubricCreateModalCreateHeader: "Create Rubric";
+    readonly rubricCreateModalEditHeader: "Edit Rubric";
+    readonly rubricsForContextNextPage: "Next Page";
+    readonly rubricsForContextPrevPage: "Previous Page";
+    readonly rubricSearchRowCriterion: "criterion";
+    readonly rubricSearchRowPreviewLabel: "Preview Rubric";
+    readonly rubricSearchRowSelectLabel: "select %{title}";
+    readonly rubricSearchRowUnscored: "Unscored";
+    readonly rubricSearchFooterAdd: "Add";
+    readonly rubricContextSelectAccountPrefix: "Account";
+    readonly rubricContextSelectCoursePrefix: "Course";
+    readonly rubricContextSelectEmptyHeading: "No Rubrics Found";
+    readonly rubricContextSelectLabel: "select account or course";
+    readonly rubricSearchTrayHeading: "Find Rubric";
+    readonly rubricSearchTrayInputLabel: "search rubrics input";
+    readonly rubricSearchTrayInputPlaceholder: "Search rubrics";
+    readonly rubricSearchTrayLabel: "Rubric Search Tray";
+    readonly rubricAssignmentSelfAssessmentInfoButtonLabel: "Why is self assessment disabled?";
+    readonly rubricAssignmentSelfAssessmentInfoText: "This toggle will be disabled if the due date has passed OR there have already been self-assessments made on this assignment OR if the assignment is a group assignment.";
+    readonly rubricAssignmentSelfAssessmentLabel: "Enable self assessment";
+    readonly rubricAssignmentSelfAssessmentUpdateError: "Failed to update self assessment settings";
+    readonly rubricAssignmentDeleteBody: "Are you sure you want to delete this rubric?";
+    readonly rubricAssignmentDeleteTitle: "Delete Rubric?";
+    readonly rubricAssignmentUnlink: "Unlink";
+    readonly rubricAssignmentUnlinkBody: "The rubric is associated with an account, course, or another assignment. You can remove this rubric from the assignment without impacting other assignments by unlinking it.";
+    readonly rubricAssignmentUnlinkTitle: "Unlink Rubric";
+    readonly viewRubricsArchivedTabLabel: "Archived";
+    readonly viewRubricsArchiveError: "Error Archiving Rubric";
+    readonly viewRubricsArchiveSuccess: "Rubric archived successfully";
+    readonly viewRubricsCreateNewRubricLabel: "Create New Rubric";
+    readonly viewRubricsDownloadError: "Error Downloading Rubrics";
+    readonly viewRubricsDownloadSelectedLabel: "Download Selected Rubrics";
+    readonly viewRubricsHeading: "Rubrics";
+    readonly viewRubricsImportRubricLabel: "Import Rubric";
+    readonly viewRubricsLoadedMoreAnnouncement: {
+        readonly one: "Loaded %{count} more rubric";
+        readonly other: "Loaded %{count} more rubrics";
+    };
+    readonly viewRubricsSavedTabLabel: "Saved";
+    readonly viewRubricsUnarchiveError: "Error Un-Archiving Rubric";
+    readonly viewRubricsUnarchiveSuccess: "Rubric un-archived successfully";
+    readonly rubricTableActionsHeader: "Actions";
+    readonly rubricTableCaption: "Rubrics";
+    readonly rubricTableCriterionHeader: "Criteria";
+    readonly rubricTableDraftPill: "Draft";
+    readonly rubricTableLocationsHeader: "Location Used";
+    readonly rubricTableLocationsLink: "courses and assignments";
+    readonly rubricTableNameHeader: "Rubric Name";
+    readonly rubricTablePointsHeader: "Total Points";
+    readonly rubricTableSelectRubricLabel: "Select %{title}";
+    readonly rubricTableSortByLabel: "Sort by";
+    readonly rubricsInfiniteFooterDisplayedCount: "%{loaded} of %{total} displayed";
+    readonly rubricsInfiniteFooterLoadMore: "Load More";
+    readonly rubricsSearchInputLabel: "Search Rubrics";
+    readonly rubricsSearchInputPlaceholder: "Search...";
+    readonly rubricPopoverArchiveLabel: "Archive";
+    readonly rubricPopoverCopyToLabel: "Copy To";
+    readonly rubricPopoverOptionsLabel: "Rubric options for %{rubricTitle}";
+    readonly rubricPopoverUnarchiveLabel: "Un-Archive";
+    readonly usedLocationsModalConcluded: "Concluded";
+    readonly usedLocationsModalFetchFailed: "Failed to load used locations";
+    readonly usedLocationsModalLoading: "Loading";
+    readonly usedLocationsModalSearchLabel: "Search";
+    readonly usedLocationsModalSearchPlaceholder: "Search...";
+    readonly usedLocationsModalTitle: "Locations Used";
+    readonly duplicateRubricModalBody: "Are you sure you want to duplicate this rubric?";
+    readonly duplicateRubricModalError: "There was an error duplicating the rubric.";
+    readonly duplicateRubricModalLabel: "Duplicate Rubric Modal";
+    readonly duplicateRubricModalSuccess: "Rubric duplicated successfully";
+    readonly duplicateRubricModalTitle: "Duplicate %{title}";
+    readonly deleteRubricModalBody: "Are you sure you want to delete this rubric?";
+    readonly deleteRubricModalError: "There was an error deleting the rubric.";
+    readonly deleteRubricModalLabel: "Delete Rubric Modal";
+    readonly deleteRubricModalSuccess: "Rubric deleted successfully";
+    readonly deleteRubricModalTitle: "Delete %{title}";
+    readonly nutritionFactsCurrentFeatureLabel: "Current Feature:";
+    readonly nutritionFactsModalLabel: "This is a modal for AI facts";
+    readonly nutritionFactsPermissionLevelsModalLabel: "This is a Data Permission Levels modal";
+    readonly nutritionFactsPermissionLevelsTitle: "Data Permission Levels";
+    readonly nutritionFactsTitle: "Nutrition Facts";
+    readonly nutritionFactsTriggerLabel: "Nutrition facts";
+    readonly generateCriteriaAdditionalPromptLabel: "Additional Prompt Information";
+    readonly generateCriteriaAdditionalPromptPlaceholder: "Optional. For example, \"Target a college-level seminar.\" or \"Focus on argument substance.\" or \"Be lenient.\"";
+    readonly generateCriteriaAdditionalPromptTooLong: "Additional prompt information must be less than 1000 characters";
+    readonly generateCriteriaButtonLabel: "Generate Criteria";
+    readonly generateCriteriaGradeLevelLabel: "Grade Level";
+    readonly generateCriteriaTotalPointsError: "Total points must be a valid positive number";
+    readonly generateCriteriaTotalPointsLabel: "Total points";
+    readonly generateFormHeading: "Auto-Generate Criteria";
+    readonly gradeLevelEighth: "8th Grade";
+    readonly gradeLevelEleventh: "11th Grade";
+    readonly gradeLevelFifth: "5th Grade";
+    readonly gradeLevelFirst: "1st Grade";
+    readonly gradeLevelFourth: "4th Grade";
+    readonly gradeLevelHigherEd: "Higher Education";
+    readonly gradeLevelKindergarten: "Kindergarten";
+    readonly gradeLevelNinth: "9th Grade";
+    readonly gradeLevelSecond: "2nd Grade";
+    readonly gradeLevelSeventh: "7th Grade";
+    readonly gradeLevelSixth: "6th Grade";
+    readonly gradeLevelTenth: "10th Grade";
+    readonly gradeLevelThird: "3rd Grade";
+    readonly gradeLevelTwelfth: "12th Grade";
+    readonly numberOfCriteriaLabel: "Number of Criteria";
+    readonly numberOfRatingsLabel: "Number of Ratings";
+    readonly standardObjectiveLabel: "Standard / Outcome Information";
+    readonly standardObjectivePlaceholder: "Optional. Place standard or outcome here. For example, \"Students will analyze primary sources\".";
+    readonly standardObjectiveTooLong: "Standard and Outcome information must be less than 1000 characters";
+    readonly criteriaAutoGeneratedLabel: "Criteria Auto-Generated";
+    readonly noCriteriaForRegenerationTooltip: "There are no criteria available for regeneration";
+    readonly feedbackModalCancelLabel: "Cancel feedback";
+    readonly feedbackModalCommentLabel: "Feedback Comment";
+    readonly feedbackModalCommentPlaceholder: "Enter your feedback here. For example, \"The criteria were well-structured.\" or \"The ratings did not match my expectations.\"";
+    readonly feedbackModalCommentTooLong: "Feedback must be less than %{limit} characters";
+    readonly feedbackModalDescription: "Please share any additional thoughts about the generated criteria. Your feedback helps us improve.";
+    readonly feedbackModalSubmit: "Submit";
+    readonly feedbackModalSubmitFailed: "Failed to submit feedback. Please try again.";
+    readonly feedbackModalSubmitting: "Submitting";
+    readonly feedbackModalThankYou: "Thank you for your feedback!";
+    readonly generatedCriteriaFeedbackLabel: "Feedback";
+    readonly negativeFeedbackLabel: "Negative Feedback";
+    readonly positiveFeedbackLabel: "Positive Feedback";
+    readonly regenerateButtonLabel: "Regenerate";
+    readonly regenerateModalCriteriaLabel: "Regenerate Criteria";
+    readonly regenerateModalCriterionLabel: "Regenerate Criterion";
+    readonly regenerateModalDescriptionCriteria: "Please provide more information about how you would like to regenerate the criteria.";
+    readonly regenerateModalDescriptionCriterion: "Please provide more information about how you would like to regenerate the criterion.";
+    readonly regenerateModalPromptLabel: "Additional Prompt Information";
+    readonly regenerateModalPromptPlaceholder: "Enter additional prompt information here. For example, \"Target a college-level seminar.\" or \"Focus on argument substance.\" or \"Be lenient.\" ";
+    readonly regenerateModalPromptTooLong: "Additional prompt information must be less than 1000 characters";
+    readonly generateCriteriaFailed: "Failed to generate criteria";
+    readonly regenerateCriteriaFailed: "Failed to regenerate criteria";
+    readonly createLabel: "Create";
+    readonly createNewRubricTitle: "Create New Rubric";
+    readonly editRubricTitle: "Edit Rubric";
+    readonly failedToOpenOutcomeDialog: "Failed to open the outcome dialog";
+    readonly outcomeDialogDuplicateWarning: "This Outcome has not been added as it already exists in this rubric.";
+    readonly rubricNameLabel: "Rubric Name";
+    readonly rubricNameRequired: "Rubric requires a name";
+    readonly rubricNameTooLong: "The Rubric Name must be between 1 and 255 characters.";
+    readonly calculationMethodAchieveMastery: {
+        readonly one: "Achieve mastery %{count} time";
+        readonly other: "Achieve mastery %{count} times";
+    };
+    readonly calculationMethodAverage: "Average";
+    readonly calculationMethodAverageDescription: "Central value in a set of results. Calculated by dividing the sum of all item scores by the number of scores.";
+    readonly calculationMethodAverageWarning: "Average is not a good fit for most outcomes-based or mastery-based learning use cases because students may need time to reach mastery of an outcome and early poorer performance can bring down an average.";
+    readonly calculationMethodBetween1And10: "Between 1 and 10";
+    readonly calculationMethodBetween1And99Percent: "Between 1% and 99%";
+    readonly calculationMethodBetween50And99Percent: "Between 50% and 99%";
+    readonly calculationMethodDecayingAverage: "Decaying Average";
+    readonly calculationMethodDecayingAverageDescription: "Most recent result counts as %{calculation_int} of mastery weight, average of all other results count as %{remainder} of weight. If there is only one result, the single score will be returned.";
+    readonly calculationMethodDecayingAverageRatio: "%{recentInt}/%{remainderInt} Decaying Average";
+    readonly calculationMethodDecayingAverageWithInts: "Decaying Average - %{recentInt}%/%{remainderInt}%";
+    readonly calculationMethodHighestScore: "Highest Score";
+    readonly calculationMethodHighestScoreDescription: "Mastery score reflects the highest score of a graded assignment or quiz.";
+    readonly calculationMethodItems: "Items: ";
+    readonly calculationMethodLastItem: "Last Item: ";
+    readonly calculationMethodLatestScore: "Latest Score";
+    readonly calculationMethodLatestScoreDescription: "Mastery score reflects the most recent graded assignment or quiz.";
+    readonly calculationMethodMostRecentItem: "Most Recent Item: ";
+    readonly calculationMethodMostRecentScore: "Most Recent Score";
+    readonly calculationMethodMustBeBetween1And10: "must be between 1 and 10";
+    readonly calculationMethodMustBeBetween1And99: "must be between 1 and 99";
+    readonly calculationMethodMustBeBetween50And99: "must be between 50 and 99";
+    readonly calculationMethodNMastery: "n Number of Times";
+    readonly calculationMethodNMasteryDescription: {
+        readonly one: "Must achieve mastery at least %{count} time. Scores above mastery will be averaged to calculate final score.";
+        readonly other: "Must achieve mastery at least %{count} times. Scores above mastery will be averaged to calculate final score.";
+    };
+    readonly calculationMethodNumberOfTimes: "# of times";
+    readonly calculationMethodWeightedAverage: "Weighted Average";
+    readonly calculationMethodWeightedAverageDescription: "Between two assessments, the most recent assessment gets %{calculation_int} weight, and the first gets %{remainder}. For each additional assessment, the sum of the previous score calculations decay by an additional %{remainder}. If there is only one result, the single score will be returned.";
+    readonly calculationMethodWeightedAverageRatio: "%{recentInt}/%{remainderInt} Weighted Average";
+    readonly calculationMethodWeightedAverageWithInts: "Weighted Average - %{recentInt}%/%{remainderInt}%";
+    readonly calculationMethodWeightingForLastItem: "% weighting for last item";
+    readonly calculationMethodWeightingOfMostRecentItem: "% weighting of most recent item";
+    readonly assessmentPeerReviewHeader: "Peer Review";
+    readonly assessmentRubricHeader: "Rubric";
+    readonly assessmentSubmit: "Submit Assessment";
+    readonly assessmentTrayLabel: "Rubric Assessment Tray";
+    readonly assessmentViewSelfAssessmentToggle: "View Student Self-Assessment";
+    readonly assessmentInstructorPointsLabel: "Instructor Points %{points} out of %{total}";
+    readonly assessmentPointsInputLabel: "Points";
+    readonly assessmentSelfAssessmentPointsLabel: "Self Assessment Points %{points} out of %{total}";
+    readonly assessmentValidationLeaveComment: "Please leave a comment";
+    readonly assessmentValidationSelectRating: "Please select a rating";
+    readonly assessmentValidationSelectRatingOrScore: "Please select a rating or enter a score";
+    readonly assessmentValidationSelectScore: "Please select a score";
+    readonly assessmentClear: "Clear";
+    readonly assessmentCommentLibrary: "Comment Library";
+    readonly assessmentCriterionComment: "Criterion Comment";
+    readonly assessmentCriterionCommentsFor: "Criterion comments for %{description}";
+    readonly assessmentCriterionScore: "Criterion Score";
+    readonly assessmentLeaveComment: "Leave a comment";
+    readonly assessmentSaveCommentForReuse: "Save this comment for reuse";
+    readonly assessmentSelectRating: "Select a rating";
+    readonly assessmentCommentsHeader: "Comments";
+    readonly assessmentCriteriaHeader: "Criteria";
+    readonly assessmentPointsHeader: "Points";
+    readonly assessmentRatingsHeader: "Ratings";
+    readonly assessmentRubricCaption: "Rubric";
+    readonly assessmentThreshold: "Threshold: %{threshold}";
+    readonly assessmentViewLongerDescription: "view longer description";
+    readonly assessmentOutcomeCalculationMethod: "Calculation Method";
+    readonly assessmentOutcomeExample: "Example";
+    readonly assessmentOutcomePopoverLabel: "Rubric Outcome Popover";
+    readonly assessmentOutcomeTagLabel: "Outcome: %{displayName}";
+    readonly outcomeContextTagCourse: "Course";
+    readonly outcomeContextTagCourseLevel: "This is a course-level outcome";
+    readonly outcomeContextTagInstitution: "Institution";
+    readonly outcomeContextTagInstitutionLevel: "This is an institution-level outcome";
+    readonly assessmentAiUsageButton: "AI Assisted";
+    readonly assessmentAiUsageDescription: "To support more fair and consistent grading, AI was used to assist in the grading process. All final grades are determined by your instructor.";
+    readonly assessmentViewMode: "View Mode";
+    readonly assessmentViewModeHorizontal: "Horizontal";
+    readonly assessmentViewModeTraditional: "Traditional";
+    readonly assessmentViewModeVertical: "Vertical";
+    readonly assessmentInstructorScore: "Instructor Score";
+    readonly assessmentPeerReviewScore: "Peer Review Score";
+    readonly assessmentStatusComplete: "Complete";
+    readonly assessmentStatusIncomplete: "Incomplete";
+    readonly assessmentSelfAssessmentCommentedAt: ", %{dueDate} at %{time}";
+    readonly assessmentSelfAssessmentEvaluate: "Evaluate your work as you believe your instructor would.";
+    readonly assessmentSelfAssessmentPrompt: "How well did you do?";
+    readonly assessmentSelfAssessmentReviewNotice: "Keep in mind that your instructor can review your self-assessment.";
+    readonly assessmentSelfAssessmentScore: "Self-Assessment Score";
+    readonly assessmentComment: "Comment";
+    readonly assessmentCommentAriaLabel: "Assessment Comment";
+    readonly assessmentCommentLibraryAssistiveText: "Select from saved comments";
+    readonly assessmentCommentLibraryEllipsis: "…";
+    readonly assessmentLongDescriptionHeader: "Criterion Long Description";
+    readonly assessmentRatingButtonLabel: "Rating Button %{buttonLabel} %{selectedText}";
+    readonly assessmentRatingSelected: "Selected";
+    readonly assessmentRatingSelectedAndSelfAssessment: "Selected and Self Assessment";
+    readonly assessmentRatingSelfAssessment: "Self Assessment";
+    readonly createFromOutcomeButton: "Create From Outcome";
+    readonly draftNewCriterionButton: "Draft New Criterion";
+    readonly newCriteriaActionsHeader: "New Criteria Actions";
+    readonly numberColumnHeader: "Number";
+    readonly reorderColumnHeader: "Reorder";
+    readonly criterionOptionsLabel: "Criterion Options";
+    readonly aiGeneratedIconTitle: "Ignite AI Generated";
+    readonly freeformCommentAreaHint: "This area will be used by the assessor to leave comments related to this criterion.";
+    readonly outcomeCannotEditTooltip: "An outcome can't be edited";
+    readonly reorderCriterionAriaLabel: "Reorder %{criterionName} Criterion";
+    readonly criterionMovedAnnouncement: "Criterion moved to position %{position}";
+    readonly ratingScaleColRating: "Rating";
+    readonly ratingScaleColScale: "Scale";
+    readonly ratingScaleSummary: "Rating Scale: %{ratingsLength}";
+    readonly deleteLabel: "Delete";
+    readonly moveDownLabel: "Move Down";
+    readonly moveUpLabel: "Move Up";
+    readonly ratingOptionsLabel: "Rating Options";
+    readonly addRatingButtonLabel: "Add Rating";
+    readonly addRatingRowLabel: "Add New Rating";
+    readonly addRatingScreenReaderLabel: "Add new rating";
+    readonly pointRangeLabel: "Point Range";
+    readonly pointsLabel: "Points";
+    readonly rangeStartPrefix: ">%{rangeStart} to ";
+    readonly ratingDescriptionLabel: "Rating Description";
+    readonly ratingNameLabel: "Rating Name";
+    readonly ratingNameRequired: "Rating Name Required";
+    readonly ratingsHeaderDisplay: "Display";
+    readonly removeRatingAriaLabel: "Remove %{ratingName} Rating";
+    readonly reorderRatingAriaLabel: "Reorder %{ratingName} Rating";
+    readonly criterionLongDescriptionLabel: "Criterion Description";
+    readonly criterionLongDescriptionPlaceholder: "Enter the description";
+    readonly criterionNameLabel: "Criterion Name";
+    readonly criterionNamePlaceholder: "Enter the name";
+    readonly criterionModalCreateTitle: "Create New Criterion";
+    readonly criterionModalEditTitle: "Edit Criterion";
+    readonly criterionModalEnableRange: "Enable Range";
+    readonly criterionModalLabel: "Rubric Criterion Modal";
+    readonly criterionModalMaximumPointsScreenReader: "Maximum Points";
+    readonly criterionModalNameRequired: "Criteria Name Required";
+    readonly criterionModalPointsPossible: "Points Possible";
+    readonly criterionModalRatingScaleHeading: "Rating Scale";
+    readonly criterionModalSaveCriterion: "Save Criterion";
+    readonly errorPageCommentFailed: "Comment failed to post! Please try again later.";
+    readonly errorPageCommentSubmitted: "Comment submitted!";
+    readonly errorPageEmailPlaceholder: "email@example.com";
+    readonly errorPageHelpUsImprove: "Help us improve by telling us what happened";
+    readonly errorPageLoading: "Loading";
+    readonly errorPageNotFoundDescription: "We couldn't find that page!";
+    readonly errorPageNotFoundTitle: "Whoops... Looks like nothing is here!";
+    readonly errorPageReportIssue: "Report Issue";
+    readonly errorPageSomethingBroke: "Sorry, Something Broke";
+    readonly errorPageSubmit: "Submit";
+    readonly errorPageWhatHappened: "What happened?";
+    readonly errorPageYourEmailAddress: "Your Email Address";
+    readonly rubricErrorPageCategory: "Edit Rubric Error Page";
+    readonly outcomeCriterionModalCriterionName: "Criterion Name";
+    readonly outcomeCriterionModalDescription: "Description";
+    readonly outcomeCriterionModalDisplay: "Display";
+    readonly outcomeCriterionModalEditCaption: "Outcome Criterion Edit";
+    readonly outcomeCriterionModalFriendlyName: "Friendly Name";
+    readonly outcomeCriterionModalLabel: "Rubric Outcome Criterion Modal";
+    readonly outcomeCriterionModalPoints: "Points";
+    readonly outcomeCriterionModalRatingName: "Rating Name";
+    readonly outcomeCriterionModalThreshold: "Threshold: %{threshold}";
+    readonly outcomeCriterionModalViewOutcome: "View Outcome";
+    readonly deleteCriterionLabel: "Delete Criterion";
+    readonly duplicateCriterionLabel: "Duplicate Criterion";
+    readonly editCriterionLabel: "Edit Criterion";
+    readonly viewOutcomeCriterionLabel: "View Outcome Criterion";
+    readonly pointsDifferenceModalBody: "Leaving the assignment's total points at %{assignmentPoints} and the rubric's total points at %{rubricPoints} will result in a maximum possible score of %{pointRatio} for student submissions graded with the rubric.";
+    readonly pointsDifferenceModalChange: "Change";
+    readonly pointsDifferenceModalLabel: "Rubric Points Difference Dialog";
+    readonly pointsDifferenceModalLeaveDifferent: "Leave Different";
+    readonly editConfirmModalConfirm: "Confirm";
+    readonly editConfirmModalLabel: "Edit Confirm Modal";
+    readonly saveConfirmModalLabel: "Rubric Save Confirmation Dialog";
+    readonly saveConfirmModalSave: "Save";
+    readonly confirmToContinueHeader: "Confirm to continue";
+    readonly gradingHistoryWarning: "This rubric has already been used for grading. Saving changes may alter student scores or grading history. Are you sure you want to proceed?";
+    readonly hideOutcomeResultsLabel: "Don't post to Learning Mastery Gradebook";
+    readonly hideScoreTotalLabel: "Hide rubric score total from students";
+    readonly useForGradingLabel: "Use this rubric for assignment grading";
+    readonly gradingTypeFreeForm: "Written Feedback";
+    readonly gradingTypeScale: "Scale";
+    readonly gradingTypeSelectLabel: "Type";
+    readonly ratingDisplayLevel: "Level";
+    readonly ratingDisplayPoints: "Points";
+    readonly ratingDisplaySelectLabel: "Rating Display";
+    readonly ratingOrderHighToLow: "High < Low";
+    readonly ratingOrderLowToHigh: "Low < High";
+    readonly ratingOrderSelectLabel: "Rating Order";
+    readonly scoringTypeScored: "Scored";
+    readonly scoringTypeSelectLabel: "Scoring";
+    readonly scoringTypeUnscored: "Unscored";
+    readonly criteriaBuilderHeaderGenerator: "Rubric Generator";
+    readonly criteriaBuilderHeaderPointsPossible: "%{pointsPossible} Points Possible";
+    readonly criteriaBuilderHeaderTitle: "Criteria Builder";
+    readonly footerCreateRubric: "Create Rubric";
+    readonly footerPreviewRubric: "Preview Rubric";
+    readonly footerSaveAsDraft: "Save as Draft";
+    readonly footerSaveRubric: "Save Rubric";
+    readonly rubricFormCannotUpdate: "Rubrics cannot be modified once they have been used in more than one place. Any saved changes will create a new rubric.";
+    readonly rubricFormLimitedEdit: "This rubric has already been used for grading. Any changes made may impact existing student scores or grading data.";
+    readonly rubricFormSaveError: "There was an error saving the rubric.";
+    readonly rubricSaveSuccess: "Rubric saved successfully";
+    readonly ratingScaleBelow: "Below";
+    readonly ratingScaleExceeds: "Exceeds";
+    readonly ratingScaleMastery: "Mastery";
+    readonly ratingScaleNear: "Near";
+    readonly ratingScaleNoEvidence: "No Evidence";
+    readonly pointsPossibleAbbreviated: "%{possible} pts";
+    readonly pointsPossibleRange: "%{possible} to >%{min} pts";
     readonly rubricSelectorAssistiveText: "Type or use arrow keys to navigate options.";
     readonly rubricSelectorEmpty: "This course has no rubrics yet.";
     readonly rubricSelectorErrorBody: "Please try again.";
@@ -14,5 +396,8 @@ export declare const i18nKeys: {
     readonly warningModalMessage: "You are about to exit the rubric editor. Any unsaved changes will be lost.";
     readonly cancel: "Cancel";
     readonly close: "Close";
+    readonly delete: "Delete";
+    readonly duplicate: "Duplicate";
+    readonly edit: "Edit";
 };
 //# sourceMappingURL=i18n.d.ts.map

package/dist/_internal/constants/i18n.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"i18n.d.ts","sourceRoot":"","sources":["../../../src/_internal/constants/i18n.ts"],"names":[],"mappings":"AAyBA,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;CAIX,CAAA"}
+{"version":3,"file":"i18n.d.ts","sourceRoot":"","sources":["../../../src/_internal/constants/i18n.ts"],"names":[],"mappings":"AAgnBA,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkEX,CAAA"}

package/dist/_internal/contexts/RubricsConfigContext.d.ts

@@ -0,0 +1,29 @@
+import { default as React } from 'react';
+export declare const DEFAULT_AI_MAX_CRITERION_COUNT = 8;
+export declare const DEFAULT_AI_MAX_RATING_COUNT = 8;
+export interface RubricsFeatureFlags {
+    rubricCriterionRange: boolean;
+    gradingRubricsPagination: boolean;
+    rubricSelfAssessmentEnabled: boolean;
+    aiRubricsEnabled: boolean;
+}
+export interface RubricsAiLimits {
+    aiRubricsMaxCriterionCount: number;
+    aiRubricsMaxRatingCount: number;
+}
+export interface RubricsConfig extends RubricsFeatureFlags, RubricsAiLimits {
+    courseId?: string;
+    accountId?: string;
+    rootOutcomeGroupId?: string;
+}
+export interface RubricsConfigProviderProps {
+    courseId?: string;
+    accountId?: string;
+    rootOutcomeGroupId?: string;
+    featureFlags?: Partial<RubricsFeatureFlags>;
+    aiLimits?: Partial<RubricsAiLimits>;
+    children: React.ReactNode;
+}
+export declare function RubricsConfigProvider({ courseId, accountId, rootOutcomeGroupId, featureFlags, aiLimits, children, }: RubricsConfigProviderProps): React.ReactElement;
+export declare function useRubricsConfig(): RubricsConfig;
+//# sourceMappingURL=RubricsConfigContext.d.ts.map

package/dist/_internal/contexts/RubricsConfigContext.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RubricsConfigContext.d.ts","sourceRoot":"","sources":["../../../src/_internal/contexts/RubricsConfigContext.tsx"],"names":[],"mappings":"AAmBA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAE9B,eAAO,MAAM,8BAA8B,IAAI,CAAA;AAC/C,eAAO,MAAM,2BAA2B,IAAI,CAAA;AAE5C,MAAM,WAAW,mBAAmB;IAClC,oBAAoB,EAAE,OAAO,CAAA;IAC7B,wBAAwB,EAAE,OAAO,CAAA;IACjC,2BAA2B,EAAE,OAAO,CAAA;IACpC,gBAAgB,EAAE,OAAO,CAAA;CAC1B;AAED,MAAM,WAAW,eAAe;IAC9B,0BAA0B,EAAE,MAAM,CAAA;IAClC,uBAAuB,EAAE,MAAM,CAAA;CAChC;AAED,MAAM,WAAW,aAAc,SAAQ,mBAAmB,EAAE,eAAe;IACzE,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,kBAAkB,CAAC,EAAE,MAAM,CAAA;CAC5B;AAwBD,MAAM,WAAW,0BAA0B;IACzC,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,kBAAkB,CAAC,EAAE,MAAM,CAAA;IAC3B,YAAY,CAAC,EAAE,OAAO,CAAC,mBAAmB,CAAC,CAAA;IAC3C,QAAQ,CAAC,EAAE,OAAO,CAAC,eAAe,CAAC,CAAA;IACnC,QAAQ,EAAE,KAAK,CAAC,SAAS,CAAA;CAC1B;AAED,wBAAgB,qBAAqB,CAAC,EACpC,QAAQ,EACR,SAAS,EACT,kBAAkB,EAClB,YAAY,EACZ,QAAQ,EACR,QAAQ,GACT,EAAE,0BAA0B,GAAG,KAAK,CAAC,YAAY,CAejD;AAED,wBAAgB,gBAAgB,IAAI,aAAa,CAEhD"}