@freshworks/crayons/dist/custom-elements/index.d.ts

Crayons Web Components library

/* crayons custom elements bundle */

import type { Components, JSX } from "../types/components";

interface FwAccordion extends Components.FwAccordion, HTMLElement {}
export const FwAccordion: {
  prototype: FwAccordion;
  new (): FwAccordion;
};

interface FwAccordionBody extends Components.FwAccordionBody, HTMLElement {}
export const FwAccordionBody: {
  prototype: FwAccordionBody;
  new (): FwAccordionBody;
};

interface FwAccordionTitle extends Components.FwAccordionTitle, HTMLElement {}
export const FwAccordionTitle: {
  prototype: FwAccordionTitle;
  new (): FwAccordionTitle;
};

interface FwAvatar extends Components.FwAvatar, HTMLElement {}
export const FwAvatar: {
  prototype: FwAvatar;
  new (): FwAvatar;
};

interface FwButton extends Components.FwButton, HTMLElement {}
export const FwButton: {
  prototype: FwButton;
  new (): FwButton;
};

interface FwButtonGroup extends Components.FwButtonGroup, HTMLElement {}
export const FwButtonGroup: {
  prototype: FwButtonGroup;
  new (): FwButtonGroup;
};

interface FwCheckbox extends Components.FwCheckbox, HTMLElement {}
export const FwCheckbox: {
  prototype: FwCheckbox;
  new (): FwCheckbox;
};

interface FwCustomCellAnchor extends Components.FwCustomCellAnchor, HTMLElement {}
export const FwCustomCellAnchor: {
  prototype: FwCustomCellAnchor;
  new (): FwCustomCellAnchor;
};

interface FwCustomCellIcon extends Components.FwCustomCellIcon, HTMLElement {}
export const FwCustomCellIcon: {
  prototype: FwCustomCellIcon;
  new (): FwCustomCellIcon;
};

interface FwCustomCellParagraph extends Components.FwCustomCellParagraph, HTMLElement {}
export const FwCustomCellParagraph: {
  prototype: FwCustomCellParagraph;
  new (): FwCustomCellParagraph;
};

interface FwCustomCellUser extends Components.FwCustomCellUser, HTMLElement {}
export const FwCustomCellUser: {
  prototype: FwCustomCellUser;
  new (): FwCustomCellUser;
};

interface FwDataTable extends Components.FwDataTable, HTMLElement {}
export const FwDataTable: {
  prototype: FwDataTable;
  new (): FwDataTable;
};

interface FwDatepicker extends Components.FwDatepicker, HTMLElement {}
export const FwDatepicker: {
  prototype: FwDatepicker;
  new (): FwDatepicker;
};

interface FwDragContainer extends Components.FwDragContainer, HTMLElement {}
export const FwDragContainer: {
  prototype: FwDragContainer;
  new (): FwDragContainer;
};

interface FwDragItem extends Components.FwDragItem, HTMLElement {}
export const FwDragItem: {
  prototype: FwDragItem;
  new (): FwDragItem;
};

interface FwFileUploader extends Components.FwFileUploader, HTMLElement {}
export const FwFileUploader: {
  prototype: FwFileUploader;
  new (): FwFileUploader;
};

interface FwFileUploaderFile extends Components.FwFileUploaderFile, HTMLElement {}
export const FwFileUploaderFile: {
  prototype: FwFileUploaderFile;
  new (): FwFileUploaderFile;
};

interface FwFileUploaderProgress extends Components.FwFileUploaderProgress, HTMLElement {}
export const FwFileUploaderProgress: {
  prototype: FwFileUploaderProgress;
  new (): FwFileUploaderProgress;
};

interface FwForm extends Components.FwForm, HTMLElement {}
export const FwForm: {
  prototype: FwForm;
  new (): FwForm;
};

interface FwFormControl extends Components.FwFormControl, HTMLElement {}
export const FwFormControl: {
  prototype: FwFormControl;
  new (): FwFormControl;
};

interface FwFormatDate extends Components.FwFormatDate, HTMLElement {}
export const FwFormatDate: {
  prototype: FwFormatDate;
  new (): FwFormatDate;
};

interface FwFormatNumber extends Components.FwFormatNumber, HTMLElement {}
export const FwFormatNumber: {
  prototype: FwFormatNumber;
  new (): FwFormatNumber;
};

interface FwIcon extends Components.FwIcon, HTMLElement {}
export const FwIcon: {
  prototype: FwIcon;
  new (): FwIcon;
};

interface FwInlineMessage extends Components.FwInlineMessage, HTMLElement {}
export const FwInlineMessage: {
  prototype: FwInlineMessage;
  new (): FwInlineMessage;
};

interface FwInput extends Components.FwInput, HTMLElement {}
export const FwInput: {
  prototype: FwInput;
  new (): FwInput;
};

interface FwLabel extends Components.FwLabel, HTMLElement {}
export const FwLabel: {
  prototype: FwLabel;
  new (): FwLabel;
};

interface FwListOptions extends Components.FwListOptions, HTMLElement {}
export const FwListOptions: {
  prototype: FwListOptions;
  new (): FwListOptions;
};

interface FwMenu extends Components.FwMenu, HTMLElement {}
export const FwMenu: {
  prototype: FwMenu;
  new (): FwMenu;
};

interface FwMenuItem extends Components.FwMenuItem, HTMLElement {}
export const FwMenuItem: {
  prototype: FwMenuItem;
  new (): FwMenuItem;
};

interface FwModal extends Components.FwModal, HTMLElement {}
export const FwModal: {
  prototype: FwModal;
  new (): FwModal;
};

interface FwModalContent extends Components.FwModalContent, HTMLElement {}
export const FwModalContent: {
  prototype: FwModalContent;
  new (): FwModalContent;
};

interface FwModalFooter extends Components.FwModalFooter, HTMLElement {}
export const FwModalFooter: {
  prototype: FwModalFooter;
  new (): FwModalFooter;
};

interface FwModalTitle extends Components.FwModalTitle, HTMLElement {}
export const FwModalTitle: {
  prototype: FwModalTitle;
  new (): FwModalTitle;
};

interface FwPagination extends Components.FwPagination, HTMLElement {}
export const FwPagination: {
  prototype: FwPagination;
  new (): FwPagination;
};

interface FwPill extends Components.FwPill, HTMLElement {}
export const FwPill: {
  prototype: FwPill;
  new (): FwPill;
};

interface FwPopover extends Components.FwPopover, HTMLElement {}
export const FwPopover: {
  prototype: FwPopover;
  new (): FwPopover;
};

interface FwProgressLoader extends Components.FwProgressLoader, HTMLElement {}
export const FwProgressLoader: {
  prototype: FwProgressLoader;
  new (): FwProgressLoader;
};

interface FwRadio extends Components.FwRadio, HTMLElement {}
export const FwRadio: {
  prototype: FwRadio;
  new (): FwRadio;
};

interface FwRadioGroup extends Components.FwRadioGroup, HTMLElement {}
export const FwRadioGroup: {
  prototype: FwRadioGroup;
  new (): FwRadioGroup;
};

interface FwSelect extends Components.FwSelect, HTMLElement {}
export const FwSelect: {
  prototype: FwSelect;
  new (): FwSelect;
};

interface FwSelectOption extends Components.FwSelectOption, HTMLElement {}
export const FwSelectOption: {
  prototype: FwSelectOption;
  new (): FwSelectOption;
};

interface FwSkeleton extends Components.FwSkeleton, HTMLElement {}
export const FwSkeleton: {
  prototype: FwSkeleton;
  new (): FwSkeleton;
};

interface FwSpinner extends Components.FwSpinner, HTMLElement {}
export const FwSpinner: {
  prototype: FwSpinner;
  new (): FwSpinner;
};

interface FwTab extends Components.FwTab, HTMLElement {}
export const FwTab: {
  prototype: FwTab;
  new (): FwTab;
};

interface FwTabPanel extends Components.FwTabPanel, HTMLElement {}
export const FwTabPanel: {
  prototype: FwTabPanel;
  new (): FwTabPanel;
};

interface FwTabs extends Components.FwTabs, HTMLElement {}
export const FwTabs: {
  prototype: FwTabs;
  new (): FwTabs;
};

interface FwTag extends Components.FwTag, HTMLElement {}
export const FwTag: {
  prototype: FwTag;
  new (): FwTag;
};

interface FwTextarea extends Components.FwTextarea, HTMLElement {}
export const FwTextarea: {
  prototype: FwTextarea;
  new (): FwTextarea;
};

interface FwTimepicker extends Components.FwTimepicker, HTMLElement {}
export const FwTimepicker: {
  prototype: FwTimepicker;
  new (): FwTimepicker;
};

interface FwToast extends Components.FwToast, HTMLElement {}
export const FwToast: {
  prototype: FwToast;
  new (): FwToast;
};

interface FwToastMessage extends Components.FwToastMessage, HTMLElement {}
export const FwToastMessage: {
  prototype: FwToastMessage;
  new (): FwToastMessage;
};

interface FwToggle extends Components.FwToggle, HTMLElement {}
export const FwToggle: {
  prototype: FwToggle;
  new (): FwToggle;
};

interface FwToggleGroup extends Components.FwToggleGroup, HTMLElement {}
export const FwToggleGroup: {
  prototype: FwToggleGroup;
  new (): FwToggleGroup;
};

interface FwToggleGroupButton extends Components.FwToggleGroupButton, HTMLElement {}
export const FwToggleGroupButton: {
  prototype: FwToggleGroupButton;
  new (): FwToggleGroupButton;
};

interface FwTooltip extends Components.FwTooltip, HTMLElement {}
export const FwTooltip: {
  prototype: FwTooltip;
  new (): FwTooltip;
};

/**
 * Utility to define all custom elements within this package using the tag name provided in the component's source. 
 * When defining each custom element, it will also check it's safe to define by:
 *
 * 1. Ensuring the "customElements" registry is available in the global context (window).
 * 2. The component tag name is not already defined.
 *
 * Use the standard [customElements.define()](https://developer.mozilla.org/en-US/docs/Web/API/CustomElementRegistry/define) 
 * method instead to define custom elements individually, or to provide a different tag name.
 */
export declare const defineCustomElements: (opts?: any) => void;

/**
 * Used to manually set the base path where assets can be found.
 * If the script is used as "module", it's recommended to use "import.meta.url",
 * such as "setAssetPath(import.meta.url)". Other options include
 * "setAssetPath(document.currentScript.src)", or using a bundler's replace plugin to
 * dynamically set the path at build time, such as "setAssetPath(process.env.ASSET_PATH)".
 * But do note that this configuration depends on how your script is bundled, or lack of
 * bunding, and where your assets can be loaded from. Additionally custom bundling
 * will have to ensure the static assets are copied to its build directory.
 */
export declare const setAssetPath: (path: string) => void;

export interface SetPlatformOptions {
  raf?: (c: FrameRequestCallback) => number;
  ael?: (el: EventTarget, eventName: string, listener: EventListenerOrEventListenerObject, options: boolean | AddEventListenerOptions) => void;
  rel?: (el: EventTarget, eventName: string, listener: EventListenerOrEventListenerObject, options: boolean | AddEventListenerOptions) => void;
  ce?: (eventName: string, opts?: any) => CustomEvent;
}
export declare const setPlatformOptions: (opts: SetPlatformOptions) => void;

export type { Components, JSX };

export * from '../types';