@esri/hub-common 13.17.2 → 13.17.4

package/dist/types/discussions/api/utils/request.d.ts

@@ -0,0 +1,25 @@
+import { RemoteServerError as _RemoteServerError } from "../../../request";
+import { IDiscussionsRequestOptions } from "../types";
+export declare class RemoteServerError extends _RemoteServerError {
+    error: string;
+    constructor(message: string, url: string, status: number, error: string);
+}
+/**
+ * returns Promise that resolves token to use in Discussions API requests
+ *
+ * @export
+ * @param {IDiscussionsRequestOptions} options
+ * @return {*}  {Promise<string>}
+ */
+export declare function authenticateRequest(options: IDiscussionsRequestOptions): Promise<string>;
+/**
+ * parses IDiscussionsRequestOptions and makes request against Discussions API
+ *
+ * @export
+ * @template T
+ * @param {string} route
+ * @param {IDiscussionsRequestOptions} options
+ * @param {string} [token]
+ * @return {*}  {Promise<T>}
+ */
+export declare function apiRequest<T>(route: string, options: IDiscussionsRequestOptions, token?: string): Promise<T>;

package/dist/types/features/checkFeature.d.ts

@@ -0,0 +1,10 @@
+import { HubFeature, IFeatureAccessResponse } from "./types";
+import { IArcGISContext, HubEntity, IHubItemEntity } from "../index";
+/**
+ * Check if a capability is enabled for a given entity and if the current user has necessary permissions to access it
+ * @param capability
+ * @param context
+ * @param entity
+ * @returns
+ */
+export declare function checkFeature(feature: HubFeature, context: IArcGISContext, entity: IHubItemEntity | HubEntity): IFeatureAccessResponse;

package/dist/types/features/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./types";
+export * from "./checkFeature";

package/dist/types/features/types.d.ts

@@ -0,0 +1,31 @@
+import { IAccessResponse } from "../core/types/IAccessResponse";
+/**
+ * Hub System Features
+ */
+declare const validFeaures: readonly ["workspaces"];
+/**
+ * Defines the possible values for HubFeature
+ */
+export declare type HubFeature = (typeof validFeaures)[number];
+/**
+ * Hash of with keys constrained to Capability
+ */
+export declare type HubFeatures = {
+    [key in HubFeature]?: boolean;
+};
+/**
+ * Validate a feature. This is used because the libary can be used outside of typescript and we want to be able to return a message is the string passed in is not a valid capability
+ * @param Feature
+ * @returns
+ */
+export declare function isHubFeature(maybeFeature: string): boolean;
+/**
+ * Response from checking a Capability
+ */
+export interface IFeatureAccessResponse extends IAccessResponse {
+    /**
+     * Capability being checked
+     */
+    feature: HubFeature;
+}
+export {};

package/dist/types/groups/HubGroup.d.ts

@@ -0,0 +1,114 @@
+import { IHubGroup, IHubGroupEditor } from "../core/types/IHubGroup";
+import { IEntityPermissionPolicy, IPermissionAccessResponse, Permission } from "../permissions";
+import { IWithStoreBehavior } from "../core/behaviors/IWithStoreBehavior";
+import { IWithPermissionBehavior } from "../core/behaviors/IWithPermissionBehavior";
+import { IArcGISContext } from "../ArcGISContext";
+import { IEditorConfig, IWithEditorBehavior } from "../core/behaviors/IWithEditorBehavior";
+import { GroupEditorType } from "./_internal/GroupSchema";
+import { IEntityEditorContext } from "../core";
+/**
+ * Hub Group Class
+ */
+export declare class HubGroup implements IWithStoreBehavior<IHubGroup>, IWithPermissionBehavior, IWithEditorBehavior {
+    protected context: IArcGISContext;
+    protected entity: IHubGroup;
+    protected isDestroyed: boolean;
+    protected thumbnailCache: {
+        file?: any;
+        filename?: string;
+        clear?: boolean;
+    };
+    private constructor();
+    /**
+     * Whether the user can edit the group,
+     * only the owner or admins of the group can
+     */
+    get canEdit(): boolean;
+    /**
+     * Whether the user can delete the group
+     * only the owner or admins of the group can
+     */
+    get canDelete(): boolean;
+    /**
+     * Whether the group is protected, if so, it can't be deleted
+     */
+    get isProtected(): boolean;
+    /**
+     * Create an instance from an IHubGroup object
+     * @param json - JSON object to create a HubGroup from
+     * @param context - ArcGIS context
+     * @returns
+     */
+    static fromJson(json: Partial<IHubGroup>, context: IArcGISContext): HubGroup;
+    /**
+     * Create a new HubGroup, returning a HubGroup instance.
+     * Note: This does not persist the Group into the backing store
+     * @param partialGroup
+     * @param context
+     * @returns
+     */
+    static create(partialGroup: Partial<IHubGroup>, context: IArcGISContext, save?: boolean): Promise<HubGroup>;
+    /**
+     * Fetch a Group from the backing store and return a HubGroup instance.
+     * @param identifier - Identifier of the group to load
+     * @param context
+     * @returns
+     */
+    static fetch(identifier: string, context: IArcGISContext): Promise<HubGroup>;
+    private static applyDefaults;
+    /**
+     * Return the backing entity as an object literal
+     */
+    toJson(): IHubGroup;
+    /**
+     * Apply a new state to the instance
+     * @param changes
+     */
+    update(changes: Partial<IHubGroup>): void;
+    /**
+     * Save the HubGroup to the backing store
+     * @returns
+     */
+    save(): Promise<void>;
+    /**
+     * Delete the HubGroup from the store
+     * set a flag to indicate that it is destroyed
+     * @returns
+     */
+    delete(): Promise<void>;
+    /**
+     * Check if current user has a specific permission, accounting for
+     * both system and entity level policies
+     * @param permission
+     * @returns
+     */
+    checkPermission(permission: Permission): IPermissionAccessResponse;
+    /**
+     * Get all policies related to a specific permission
+     * @param permission
+     * @returns
+     */
+    getPermissionPolicies(permission: Permission): IEntityPermissionPolicy[];
+    /**
+     * Add a policy to the entity
+     * @param policy
+     */
+    addPermissionPolicy(policy: IEntityPermissionPolicy): void;
+    /**
+     * Remove a policy from the entity
+     * @param permission
+     * @param id
+     */
+    removePermissionPolicy(permission: Permission, id: string): void;
+    getEditorConfig(i18nScope: string, type: GroupEditorType): Promise<IEditorConfig>;
+    /**
+     * Return the group as an editor object
+     */
+    toEditor(editorContext?: IEntityEditorContext, include?: string[]): Promise<IHubGroupEditor>;
+    /**
+     * Load the group from the editor object
+     * @param editor
+     * @returns
+     */
+    fromEditor(editor: IHubGroupEditor): Promise<IHubGroup>;
+}

package/dist/types/groups/_internal/AddOrInviteUsersToGroupUtils.d.ts

@@ -0,0 +1,82 @@
+import { IAddOrInviteContext, IAddOrInviteResponse, IUserOrgRelationship, IUserWithOrgType } from "../types";
+/**
+ * @private
+ * Handles add/invite logic for collaboration coordinators inside partnered orgs.
+ * This is intentionally split out from the invitation of partnered org normal members,
+ * because the two types of partnered org usres (regular and collaboration coordinator)
+ * always come from the same 'bucket', however have distinctly different add paths Invite vs auto add.
+ * It returns either an empty instance of the addOrInviteResponse
+ * object, or their response from auto adding users.
+ *
+ * @export
+ * @param {IAddOrInviteContext} context context object
+ * @return {IAddOrInviteResponse} response object
+ */
+export declare function addOrInviteCollaborationCoordinators(context: IAddOrInviteContext): Promise<IAddOrInviteResponse>;
+/**
+ * @private
+ * Handles add/invite logic for community users
+ * It returns either an empty instance of the addOrInviteResponse
+ * object, or either ther esponse from processing auto adding
+ * users or inviting users. If an email has been passed in it also notifies
+ * processAutoAddUsers that emails should be sent.
+ *
+ * @export
+ * @param {IAddOrInviteContext} context context object
+ * @return {IAddOrInviteResponse} response object
+ */
+export declare function addOrInviteCommunityUsers(context: IAddOrInviteContext): Promise<IAddOrInviteResponse>;
+/**
+ * @private
+ * Handles add/invite logic for Org users
+ * It returns either an empty instance of the addOrInviteResponse
+ * object, or either ther esponse from processing auto adding a users or inviting a user
+ *
+ * @export
+ * @param {IAddOrInviteContext} context context object
+ * @return {IAddOrInviteResponse} response object
+ */
+export declare function addOrInviteOrgUsers(context: IAddOrInviteContext): Promise<IAddOrInviteResponse>;
+/**
+ * @private
+ * Handles add/invite logic for partnered org users.
+ * It returns either an empty instance of the addOrInviteResponse
+ * object, or their response from inviting users.
+ *
+ * @export
+ * @param {IAddOrInviteContext} context context object
+ * @return {IAddOrInviteResponse} response object
+ */
+export declare function addOrInvitePartneredUsers(context: IAddOrInviteContext): Promise<IAddOrInviteResponse>;
+/**
+ * @private
+ * Handles add/invite logic for world users
+ * It either returns an empty instance of the add/invite response
+ * object, or a populated version from processInviteUsers
+ *
+ * @export
+ * @param {IAddOrInviteContext} context Context object
+ * @return {IAddOrInviteResponse} Response object
+ */
+export declare function addOrInviteWorldUsers(context: IAddOrInviteContext): Promise<IAddOrInviteResponse>;
+/**
+ * @private
+ * Returns an empty instance of the addorinviteresponse object.
+ * We are using this because if you leave out any of the props
+ * from the final object and you are concatting together arrays you can concat
+ * an undeifined inside an array which will throw off array lengths.
+ *
+ * @export
+ * @return {IAddOrInviteResponse}
+ */
+export declare function handleNoUsers(context?: IAddOrInviteContext, userType?: "world" | "org" | "community" | "partnered", shouldEmail?: boolean): Promise<IAddOrInviteResponse>;
+/**
+ * @private
+ * Takes users array and sorts them into an object by the type of user they are
+ * based on the orgType prop (world|org|community)
+ *
+ * @export
+ * @param {IUserWithOrgType[]} users array of users
+ * @return {IUserOrgRelationship} Object of users sorted by type (world, org, community)
+ */
+export declare function groupUsersByOrgRelationship(users: IUserWithOrgType[]): IUserOrgRelationship;

package/dist/types/groups/_internal/GroupBusinessRules.d.ts

@@ -0,0 +1,12 @@
+import { IPermissionPolicy } from "../../permissions";
+/**
+ * Group Permission Policies
+ * These define the requirements any user must meet to perform related actions
+ * @private
+ */
+export declare const GroupPermissions: readonly ["hub:group", "hub:group:create", "hub:group:delete", "hub:group:edit", "hub:group:view", "hub:group:owner", "hub:group:workspace:overview", "hub:group:workspace:dashboard", "hub:group:workspace:details", "hub:group:workspace:settings", "hub:group:workspace:collaborators", "hub:group:workspace:content", "hub:group:workspace:members", "hub:group:shareContent", "hub:group:manage"];
+/**
+ * Group permission policies
+ * @private
+ */
+export declare const GroupPermissionPolicies: IPermissionPolicy[];

package/dist/types/groups/_internal/GroupSchema.d.ts

@@ -0,0 +1,7 @@
+import { IConfigurationSchema } from "../../core";
+export declare type GroupEditorType = (typeof GroupEditorTypes)[number];
+export declare const GroupEditorTypes: readonly ["hub:group:edit", "hub:group:settings"];
+/**
+ * Defines the JSON schema for a Hub Group's editable fields
+ */
+export declare const GroupSchema: IConfigurationSchema;

package/dist/types/groups/_internal/GroupUiSchemaEdit.d.ts

@@ -0,0 +1,10 @@
+import { IUiSchema } from "../../core/schemas/types";
+import { IArcGISContext } from "../../ArcGISContext";
+import { IHubGroup } from "../../core/types";
+/**
+ * @private
+ * constructs the complete edit uiSchema for Hub Groups
+ * This defines how the schema properties should be
+ * rendered in the group editing experience
+ */
+export declare const buildUiSchema: (i18nScope: string, entity: IHubGroup, context: IArcGISContext) => Promise<IUiSchema>;

package/dist/types/groups/_internal/GroupUiSchemaSettings.d.ts

@@ -0,0 +1,10 @@
+import { IUiSchema } from "../../core";
+import { IArcGISContext } from "../../ArcGISContext";
+import { IHubGroup } from "../../core/types";
+/**
+ * @private
+ * constructs the complete settings uiSchema for Hub Groups
+ * This defines how the schema properties should be
+ * rendered in the group settings experience
+ */
+export declare const buildUiSchema: (i18nScope: string, entity: IHubGroup, context: IArcGISContext) => Promise<IUiSchema>;

package/dist/types/groups/_internal/autoAddUsersAsAdmins.d.ts

@@ -0,0 +1,13 @@
+import { IAddGroupUsersResult, IUser } from "@esri/arcgis-rest-portal";
+import { IAuthenticationManager } from "@esri/arcgis-rest-request";
+/**
+ * @private
+ * Auto add N users to a single group, with users added as admins of that group
+ *
+ * @export
+ * @param {string} id Group ID
+ * @param {IUser[]} admins array of users to add to group as admin
+ * @param {IAuthenticationManager} authentication authentication manager
+ * @return {IAddGroupUsersResult} Result of the transaction (null if no users are passed in)
+ */
+export declare function autoAddUsersAsAdmins(id: string, admins: IUser[], authentication: IAuthenticationManager): Promise<IAddGroupUsersResult | null>;

package/dist/types/groups/_internal/computeProps.d.ts

@@ -0,0 +1,12 @@
+import { IRequestOptions } from "@esri/arcgis-rest-request";
+import { IHubGroup } from "../../core/types/IHubGroup";
+import { IGroup } from "@esri/arcgis-rest-types";
+/**
+ * Given a model and a group, set various computed properties that can't be directly mapped
+ * @private
+ * @param group
+ * @param hubGroup
+ * @param requestOptions
+ * @returns
+ */
+export declare function computeProps(group: IGroup, hubGroup: Partial<IHubGroup>, requestOptions: IRequestOptions): IHubGroup;

package/dist/types/groups/_internal/convertGroupToHubGroup.d.ts

@@ -0,0 +1,9 @@
+import { IGroup } from "@esri/arcgis-rest-types";
+import { IHubGroup } from "../../core/types/IHubGroup";
+import { IUserRequestOptions } from "@esri/arcgis-rest-auth";
+/**
+ * Convert an IGroup to a Hub Group
+ * @param group
+ * @param requestOptions
+ */
+export declare function convertGroupToHubGroup(group: IGroup, requestOptions: IUserRequestOptions): IHubGroup;

package/dist/types/groups/_internal/convertHubGroupToGroup.d.ts

@@ -0,0 +1,7 @@
+import { IGroup } from "@esri/arcgis-rest-types";
+import { IHubGroup } from "../../core/types/IHubGroup";
+/**
+ * Convert a Hub Group to an IGroup
+ * @param hubGroup
+ */
+export declare function convertHubGroupToGroup(hubGroup: IHubGroup): IGroup;

package/dist/types/groups/_internal/getPropertyMap.d.ts

@@ -0,0 +1,8 @@
+import { IPropertyMap } from "../../core/_internal/PropertyMapper";
+/**
+ * Returns an Array of IPropertyMap objects
+ * that define the projection of properties from a IGroup to an IHubGroup
+ * @returns
+ * @private
+ */
+export declare function getPropertyMap(): IPropertyMap[];

package/dist/types/groups/_internal/processAutoAddUsers.d.ts

@@ -0,0 +1,15 @@
+import { IAddOrInviteContext, IAddOrInviteResponse } from "../types";
+/**
+ * @private
+ * Governs logic for automatically adding N users to a group.
+ * Users are added as either a regular user OR as an administrator of the group
+ * depending on the addUserAsGroupAdmin prop on the IAddOrInviteContext.
+ * If there is an email object on the IAddOrInviteContext, then email notifications are sent.
+ *
+ * @export
+ * @param {IAddOrInviteContext} context context object
+ * @param {string} userType what type of user is it: org | world | community
+ * @param {boolean} [shouldEmail=false] should the user be emailed?
+ * @return {IAddOrInviteResponse} response object
+ */
+export declare function processAutoAddUsers(context: IAddOrInviteContext, userType: "world" | "org" | "community" | "partnered" | "collaborationCoordinator", shouldEmail?: boolean): Promise<IAddOrInviteResponse>;

package/dist/types/groups/_internal/processEmailUsers.d.ts

@@ -0,0 +1,14 @@
+import { IAddOrInviteContext, IAddOrInviteResponse } from "../types";
+/**
+ * @private
+ * Governs the logic for emailing N users. It acts under the assumption
+ * that all the 'community' users are the ones being emailed (this is due to platform rules we conform to)
+ * Function is called upstream depending on if an email object is attached to the context.
+ * Email object contains its own auth as it'll require the community admin to send the email itself.
+ * An individual email call goes out for each user due to how the response of multiple users in a single call works.
+ *
+ * @export
+ * @param {IAddOrInviteContext} context context object
+ * @return {IAddOrInviteResponse} response object
+ */
+export declare function processEmailUsers(context: IAddOrInviteContext): Promise<IAddOrInviteResponse>;

package/dist/types/groups/_internal/processInviteUsers.d.ts

@@ -0,0 +1,13 @@
+import { IAddOrInviteContext, IAddOrInviteResponse } from "../types";
+/**
+ * @private
+ * Governs the logic for inviting N users to a single group.
+ * An individual invite call goes out for each user and the results are consolidated.
+ * See comment in function about the for...of loop which explains reasoning.
+ *
+ * @export
+ * @param {IAddOrInviteContext} context context object
+ * @param {string} userType what type of user is it: org | world | community
+ * @return {IAddOrInviteResponse} response object
+ */
+export declare function processInviteUsers(context: IAddOrInviteContext, userType: "world" | "org" | "community" | "partnered"): Promise<IAddOrInviteResponse>;

package/dist/types/groups/addOrInviteUsersToGroup.d.ts

@@ -0,0 +1,18 @@
+import { IAuthenticationManager } from "@esri/arcgis-rest-request";
+import { IAddOrInviteEmail, IAddOrInviteToGroupResult, IUserWithOrgType } from "./types";
+/**
+ * Add or invite N users to a single group
+ * Org|community|world logic flows are run even if there are no users applicable for that particular path.
+ * Results from each path are consolidated and surfaced in the return object as failures and errors are of
+ * more importance than successes.
+ *
+ * @export
+ * @param {string} groupId Group we are adding users to
+ * @param {IUserWithOrgType[]} users array of users to add
+ * @param {IAuthenticationManager} primaryRO primary requestOptions
+ * @param {boolean} canAutoAddUser Can we automatically add a user to the group?
+ * @param {boolean} addUserAsGroupAdmin Should the user be added as a group administrator
+ * @param {IAddOrInviteEmail} email Email object
+ * @return {IAddOrInviteToGroupResult} Result object
+ */
+export declare function addOrInviteUsersToGroup(groupId: string, users: IUserWithOrgType[], primaryRO: IAuthenticationManager, canAutoAddUser: boolean, addUserAsGroupAdmin: boolean, email: IAddOrInviteEmail): Promise<IAddOrInviteToGroupResult>;

package/dist/types/groups/addOrInviteUsersToGroups.d.ts

@@ -0,0 +1,30 @@
+import { ArcGISRequestError, IAuthenticationManager } from "@esri/arcgis-rest-request";
+import { IAddOrInviteEmail, IAddOrInviteToGroupResult, IUserWithOrgType } from "./types";
+/**
+ * addOrInviteUsersToGroups adds/invites N users to N groups
+ * Initial entry point function for add/invite members flow
+ * when dealing with multiple groups.
+ * Responses from each group are then consolidated into the final returned object.
+ *
+ * @export
+ * @param {string[]} groupIds array of groups we are adding users to
+ * @param {IUserWithOrgType[]} users array of users to add to those groups
+ * @param {IAuthenticationManager} primaryRO primary requestOptions
+ * @param {boolean} [canAutoAddUser=false] Can we automatically add a user to the group?
+ * @param {boolean} [addUserAsGroupAdmin=false] Can the user be added to a group as an administrator of that group?
+ * @param {IAddOrInviteEmail} [email] Email object contains auth for the email && the email object itself
+ * @return {*}  {Promise<{
+ *   notAdded: string[];
+ *   notInvited: string[];
+ *   notEmailed: string[];
+ *   errors: ArcGISRequestError[];
+ *   responses: IAddOrInviteToGroupResult[];
+ * }>} Results object
+ */
+export declare function addOrInviteUsersToGroups(groupIds: string[], users: IUserWithOrgType[], primaryRO: IAuthenticationManager, canAutoAddUser?: boolean, addUserAsGroupAdmin?: boolean, email?: IAddOrInviteEmail): Promise<{
+    notAdded: string[];
+    notInvited: string[];
+    notEmailed: string[];
+    errors: ArcGISRequestError[];
+    responses: IAddOrInviteToGroupResult[];
+}>;

package/dist/types/groups/autoAddUsers.d.ts

@@ -0,0 +1,14 @@
+import { IUser } from "@esri/arcgis-rest-auth";
+import { IAddGroupUsersResult } from "@esri/arcgis-rest-portal";
+import { IAuthenticationManager } from "@esri/arcgis-rest-request";
+/**
+ *
+ * Attempts to auto-add users to a group
+ *
+ * @param {string} id ID of the group the users will be added to
+ * @param {IUser[]} users
+ * @param {IAuthenticationManager} authentication
+ *
+ * @returns {IAddGroupUsersResult|null} Result of the transaction (null if no users are passed in)
+ */
+export declare function autoAddUsers(id: string, users: IUser[], authentication: IAuthenticationManager): Promise<IAddGroupUsersResult | null>;

package/dist/types/groups/defaults.d.ts

@@ -0,0 +1,11 @@
+import { IGroup } from "@esri/arcgis-rest-types";
+import { IHubGroup } from "../core/types/IHubGroup";
+export declare const HUB_GROUP_TYPE = "Hub Group";
+/**
+ * Default values of a IHubGroup
+ */
+export declare const DEFAULT_GROUP: Partial<IHubGroup>;
+/**
+ * Default values for a new HubGroup Model
+ */
+export declare const DEFAULT_GROUP_MODEL: IGroup;

package/dist/types/groups/deleteGroupThumbnail.d.ts

@@ -0,0 +1,9 @@
+import { IUserRequestOptions } from "@esri/arcgis-rest-auth";
+/**
+ * Delete a group's thumbnail
+ * @param id
+ * @param owner
+ * @param requestOptions
+ * @returns
+ */
+export declare function deleteGroupThumbnail(id: string, requestOptions: IUserRequestOptions): Promise<any>;

package/dist/types/groups/emailOrgUsers.d.ts

@@ -0,0 +1,15 @@
+import { IUser } from "@esri/arcgis-rest-auth";
+import { ICreateOrgNotificationResult } from "@esri/arcgis-rest-portal";
+import { IAuthenticationManager } from "@esri/arcgis-rest-request";
+import { IEmail } from "./types";
+/**
+ * Attempts to email members of the requesting user's organization.
+ *
+ * @param {IUser[]} users Users to email (must be in the same org as the requesting user)
+ * @param {IEmail} email
+ * @param {IAuthenticationManager} authentication
+ * @param {boolean} isOrgAdmin // Whether the requesting user in an org admin
+ *
+ * @returns {object|null} A promise that resolves to the result of the transaction (null if no users are passed in)
+ */
+export declare function emailOrgUsers(users: IUser[], email: IEmail, authentication: IAuthenticationManager, isOrgAdmin: boolean): Promise<ICreateOrgNotificationResult | null>;

package/dist/types/groups/inviteUsers.d.ts

@@ -0,0 +1,17 @@
+import { IUser } from "@esri/arcgis-rest-auth";
+import { IInviteGroupUsersResult } from "@esri/arcgis-rest-portal";
+import { IAuthenticationManager } from "@esri/arcgis-rest-request";
+/**
+ *
+ * Attempts to invite users to a group
+ *
+ * @param {string} id ID of the group the users will be invited to
+ * @param {object[]} users
+ * @param {object} authentication
+ * @param {number} expiration How long the invite will be active (in minutes)
+ * @param {string} role What role should they be added as. Defaults to group member
+ *
+ * @returns {object|null} Result of the transaction (null if no users are passed in)
+ */
+export declare function inviteUsers(id: string, users: IUser[], authentication: IAuthenticationManager, expiration?: number, // default to 2 week expiration TODO: is this actually 2 weeks?
+role?: "group_member" | "group_admin"): Promise<IInviteGroupUsersResult | null>;

package/dist/types/groups/setGroupThumbnail.d.ts

@@ -0,0 +1,9 @@
+import { IUserRequestOptions } from "@esri/arcgis-rest-auth";
+/**
+ * Upload a file to be used as the thumbnail for a group
+ * @param id
+ * @param file
+ * @param filename
+ * @param requestOptions
+ */
+export declare function setGroupThumbnail(id: string, file: any, filename: string, requestOptions: IUserRequestOptions, owner: string): Promise<void>;

package/dist/types/groups/types/types.d.ts

@@ -0,0 +1,72 @@
+import { ArcGISRequestError, IAuthenticationManager } from "@esri/arcgis-rest-request";
+import { IUser } from "@esri/arcgis-rest-types";
+export interface IEmail {
+    subject?: string;
+    body?: string;
+    copyMe?: boolean;
+}
+/**
+ * User object returned from add users modal in ember application
+ * It extends the IUser interface with an additional property
+ * that denotes what org relationship the user might have (world|org|community|partnered|collaborationCoordinator)
+ */
+export interface IUserWithOrgType extends IUser {
+    orgType: "world" | "org" | "community" | "partnered" | "collaborationCoordinator";
+}
+/**
+ * User org relationship interface
+ * Object contains users parsed by their org relationship (world|org|community|partnered|collaborationCoordinator)
+ */
+export interface IUserOrgRelationship {
+    world: IUserWithOrgType[];
+    org: IUserWithOrgType[];
+    community: IUserWithOrgType[];
+    partnered: IUserWithOrgType[];
+    collaborationCoordinator: IUserWithOrgType[];
+}
+/**
+ * Interface governing the add or invite response out of process auto add / invite / emailing users
+ */
+export interface IAddOrInviteResponse {
+    users: string[];
+    errors: ArcGISRequestError[];
+    notAdded: string[];
+    notInvited: string[];
+    notEmailed: string[];
+}
+/**
+ * Email input object for add/invite flow
+ * contains both the IEmail object and auth for the email.
+ */
+export interface IAddOrInviteEmail {
+    message: IEmail;
+    auth: IAuthenticationManager;
+    groupId?: string;
+}
+/**
+ * Add or invite flow context - object that contains all the needed
+ * inputs for org/world/community users
+ */
+export interface IAddOrInviteContext extends IUserOrgRelationship {
+    groupId: string;
+    primaryRO: IAuthenticationManager;
+    allUsers: IUserWithOrgType[];
+    canAutoAddUser: boolean;
+    addUserAsGroupAdmin: boolean;
+    email: IAddOrInviteEmail;
+}
+/**
+ * Interface for result object out of addOrInviteUsersToGroup.
+ */
+export interface IAddOrInviteToGroupResult {
+    errors: ArcGISRequestError[];
+    notAdded: string[];
+    notInvited: string[];
+    notEmailed: string[];
+    community: IAddOrInviteResponse;
+    org: IAddOrInviteResponse;
+    world: IAddOrInviteResponse;
+    partnered: IAddOrInviteResponse;
+    collaborationCoordinator: IAddOrInviteResponse;
+    groupId: string;
+}

package/dist/types/initiatives/_internal/InitiativeUiSchemaCreate.d.ts

@@ -0,0 +1,13 @@
+import { IArcGISContext } from "../../ArcGISContext";
+import { IHubInitiative } from "../../core/types";
+import { IUiSchema } from "../../core/schemas/types";
+/**
+ * @private
+ * constructs the minimal create uiSchema for Hub Initiatives.
+ * This defines how the schema properties should be rendered
+ * in the initiative creation experience
+ *
+ * TODO: this was copied from projects and is just a placeholder
+ * for now - it isn't being used anywhere in the application
+ */
+export declare const buildUiSchema: (i18nScope: string, entity: IHubInitiative, context: IArcGISContext) => Promise<IUiSchema>;