@pacem/pacem-scaffolding 1.0.0-bessel → 1.0.0-dirac

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (55) hide show
  1. package/dist/browser/pacem-scaffolding.js +420 -38
  2. package/dist/browser/pacem-scaffolding.js.map +1 -1
  3. package/dist/browser/pacem-scaffolding.min.js +2 -2
  4. package/dist/bundle/pacem-scaffolding.min.mjs +91 -91
  5. package/dist/bundle/pacem-scaffolding.mjs +329 -200
  6. package/dist/bundle/pacem-scaffolding.mjs.map +3 -3
  7. package/dist/docs/pacem-scaffolding.json +34788 -0
  8. package/dist/esm/calendar-picker.js +6 -1
  9. package/dist/esm/char-counter.js +3 -1
  10. package/dist/esm/checkbox-list.js +2 -1
  11. package/dist/esm/checkbox.js +3 -1
  12. package/dist/esm/childform.js +1 -1
  13. package/dist/esm/contenteditable.js +4 -1
  14. package/dist/esm/datetime-picker.js +8 -1
  15. package/dist/esm/form.js +65 -1
  16. package/dist/esm/formfield.js +9 -1
  17. package/dist/esm/geolocate.js +2 -1
  18. package/dist/esm/hierarchy.js +6 -1
  19. package/dist/esm/index-components-scaffolding.js +1 -1
  20. package/dist/esm/index-components.js +1 -1
  21. package/dist/esm/index-iife.js +1 -1
  22. package/dist/esm/index-root.js +1 -1
  23. package/dist/esm/index-scaffolding.js +1 -1
  24. package/dist/esm/index.js +1 -1
  25. package/dist/esm/input-chars.js +4 -1
  26. package/dist/esm/input-color.js +3 -2
  27. package/dist/esm/input-email.js +13 -7
  28. package/dist/esm/input-file.js +20 -3
  29. package/dist/esm/input-hidden.js +7 -4
  30. package/dist/esm/input-image.js +13 -1
  31. package/dist/esm/input-number.js +5 -2
  32. package/dist/esm/input-password.js +6 -2
  33. package/dist/esm/input-search.js +7 -4
  34. package/dist/esm/input-tel.js +13 -7
  35. package/dist/esm/input-text.js +6 -3
  36. package/dist/esm/input-url.js +13 -7
  37. package/dist/esm/input.js +26 -1
  38. package/dist/esm/l10n.js +2 -1
  39. package/dist/esm/latlng.js +4 -1
  40. package/dist/esm/namevalue-list.js +3 -1
  41. package/dist/esm/property-picker.js +2 -1
  42. package/dist/esm/radio-list.js +2 -1
  43. package/dist/esm/radio.js +2 -1
  44. package/dist/esm/select.js +6 -2
  45. package/dist/esm/slider.js +2 -1
  46. package/dist/esm/snapshot.js +5 -1
  47. package/dist/esm/suggest.js +2 -1
  48. package/dist/esm/tags.js +3 -1
  49. package/dist/esm/textarea-markdown.js +15 -9
  50. package/dist/esm/textarea.js +13 -5
  51. package/dist/esm/types-components.js +53 -2
  52. package/dist/esm/types.js +3 -1
  53. package/dist/esm/validators.js +25 -1
  54. package/package.json +2 -1
  55. package/typings/index.d.ts +626 -14
@@ -12,6 +12,7 @@ import { Type } from '@pacem/pacem-core';
12
12
 
13
13
  declare type Address = Maps.Address;
14
14
 
15
+ /** An HTTP operation exposed by an API (method + path), together with its input parameters and expected response shape. */
15
16
  declare type ApiEndpoint = {
16
17
  method: Net.HttpMethod;
17
18
  path: string;
@@ -19,6 +20,7 @@ declare type ApiEndpoint = {
19
20
  response?: ApiResponse;
20
21
  };
21
22
 
23
+ /** The parsed, format-agnostic representation of an API surface (OpenAPI or Swagger), ready to be consumed to auto-generate form fields. */
22
24
  declare type ApiManifest = {
23
25
  definitions: {
24
26
  [name: string]: OpenApiSwagger.Schema;
@@ -27,10 +29,12 @@ declare type ApiManifest = {
27
29
  baseUrl: string;
28
30
  };
29
31
 
32
+ /** A single parameter of an {@link ApiEndpoint}, combining its name/required-ness ({@link Parameter}) with its resolved schema ({@link Schema}) and {@link ApiParameterType}. */
30
33
  declare interface ApiParameter extends Parameter, Schema {
31
34
  type?: ApiParameterType;
32
35
  }
33
36
 
37
+ /** The primitive kinds an {@link ApiParameter} (or {@link DataField}) can be translated to, used to choose the appropriate auto-generated form field editor. */
34
38
  declare enum ApiParameterType {
35
39
  String = "string",
36
40
  Number = "number",
@@ -40,26 +44,54 @@ declare enum ApiParameterType {
40
44
  Object = "object"
41
45
  }
42
46
 
47
+ /** Contract for parsing an API description (OpenAPI or Swagger), either already in memory or fetched from a url, into a format-agnostic {@link ApiManifest}. */
43
48
  declare interface ApiParser {
49
+ /**
50
+ * Parses raw API description content into an {@link ApiManifest}.
51
+ * @param content The API description, either as a parsed object or as a JSON string.
52
+ * @returns The parsed manifest.
53
+ */
44
54
  parse(content: any): ApiManifest;
55
+ /**
56
+ * Fetches an API description document from `url` and parses it into an {@link ApiManifest}.
57
+ * @param url Url the API description (OpenAPI/Swagger document) is fetched from.
58
+ * @returns The parsed manifest.
59
+ */
45
60
  load(url: string): Promise<ApiManifest>;
46
61
  }
47
62
 
63
+ /** Shared base for the OpenAPI/Swagger parsers: implements the common fetch-then-parse {@link ApiParser.load} flow, leaving the actual schema-to-{@link ApiManifest} translation to derived classes' `parse` implementation. */
48
64
  declare abstract class ApiParserBase implements ApiParser {
65
+ /**
66
+ * Parses raw API description content (OpenAPI or Swagger, depending on the concrete parser) into an {@link ApiManifest}.
67
+ * @param content The API description, either as a parsed object or as a JSON string.
68
+ * @param url Base url of the API, used to resolve/derive the manifest's `baseUrl` when not otherwise specified in the document.
69
+ * @returns The parsed manifest.
70
+ */
49
71
  abstract parse(content: any, url?: string): ApiManifest;
72
+ /**
73
+ * Fetches the API description document from `url` and parses it into an {@link ApiManifest}.
74
+ * @param url Url the API description (OpenAPI/Swagger document) is fetched from.
75
+ * @param headers Optional request headers (e.g. for authentication) sent along with the fetch.
76
+ * @returns The parsed manifest, or `null` if the response could not be retrieved/parsed as JSON.
77
+ */
50
78
  load(url: string, headers?: {
51
79
  [name: string]: string;
52
80
  }): Promise<ApiManifest>;
53
81
  }
54
82
 
83
+ /** The response schema of an {@link ApiEndpoint}. */
55
84
  declare interface ApiResponse extends Schema {
56
85
  type: string;
57
86
  }
58
87
 
88
+ /** Default shadow-DOM template shared by every built-in `p-*-validator`: a `<p-span>` (exposed as the `error-message` part) shown only while `invalid`, displaying `errorMessage`. */
59
89
  declare const BASIC_VALIDATOR_TEMPLATE: string;
60
90
 
91
+ /** How a binary/upload field lets the user pick file(s) or a directory. */
61
92
  declare type BinarySelectMode = 'file' | 'multiple' | 'directory-picker' | 'directory' | 'file-picker' | 'multiple-picker';
62
93
 
94
+ /** Serialized representation of a binary/file value (e.g. produced by upload fields), as accepted by the `binary` validator and related components. */
63
95
  declare type BinaryValue = {
64
96
  name: string;
65
97
  size: number;
@@ -69,17 +101,21 @@ declare type BinaryValue = {
69
101
  encoding?: string;
70
102
  };
71
103
 
104
+ /** Dispatched by {@link PacemCalendarPickerElement} when its clear button is used to unselect the current date. */
72
105
  declare class CalendarDateUnselectEvent extends Components_3.UI.DateSelectEvent {
73
106
  constructor();
74
107
  }
75
108
 
109
+ /** When a {@link PacemBaseInputElement} propagates its native input's value to the `value` property: on every keystroke (`Input`), or only once the field loses focus (`Blur`). */
76
110
  declare enum ChangePolicy {
77
111
  Input = "input",
78
112
  Blur = "blur"
79
113
  }
80
114
 
115
+ /** Markup fragment for a `pacem-char-count` companion element, meant to be spliced into a `@CustomElement` template so a text field can display its own character counter. */
81
116
  declare const CHAR_COUNTER_CHILD: string;
82
117
 
118
+ /** Metadata describing a command/action button (e.g. a childform item's custom toolbar command) to render alongside a generated field. */
83
119
  declare type CommandMetadata = {
84
120
  name: string;
85
121
  tooltip?: string;
@@ -89,6 +125,7 @@ declare type CommandMetadata = {
89
125
  dependsOnValue?: boolean;
90
126
  };
91
127
 
128
+ /** Comparison operators supported by the `compare` validator (see {@link KnownValidatorMetadata} and `p-compare-validator`'s `operator` property in `validators.ts`). */
92
129
  declare type CompareValidatorOperator = 'equal' | 'lessOrEqual' | 'less' | 'greater' | 'greaterOrEqual' | 'notEqual';
93
130
 
94
131
  export declare namespace Components {
@@ -97,23 +134,35 @@ export declare namespace Components {
97
134
  }
98
135
  }
99
136
 
137
+ /** A toolbar command that can act on a {@link PacemContenteditableElement}'s current selection/content. */
100
138
  declare interface ContenteditableCommand {
101
139
  exec(...args: any[]): Promise<unknown>;
102
140
  }
103
141
 
142
+ /** Watches a contenteditable host for insertion/removal of elements matching a given selector (e.g. inert `[contenteditable=false]` islands), notifying a callback for each match, recursively. */
104
143
  declare class ContenteditableDOMObserver {
105
144
  #private;
145
+ /**
146
+ * Initializes the observer, immediately scanning the given container and then watching it for further mutations.
147
+ * @param contentElement The contenteditable container to observe.
148
+ * @param mutationCallback Invoked for each matching node found, added or removed.
149
+ * @param selector CSS selector used to filter relevant nodes.
150
+ */
106
151
  constructor(contentElement: HTMLElement, mutationCallback: (item: Node, removed?: boolean) => void, selector?: string);
107
152
  private _initContainer;
108
153
  private _disposeContainer;
154
+ /** Stops observing and notifies the callback, as a removal, for every currently matching node. */
109
155
  dispose(): void;
110
156
  }
111
157
 
158
+ /** A {@link ContenteditableCommand} that also handles files pasted into the editor (e.g. image upload on paste). */
112
159
  declare interface ContenteditableFileCommand extends ContenteditableCommand {
113
160
  pasteCallback(file: File): PromiseLike<any>;
114
161
  }
115
162
 
163
+ /** Collection of static DOM/Range helper methods shared by the contenteditable command elements. */
116
164
  declare class ContenteditableUtils {
165
+ /** Builds the default toolbar dashboard (undo/redo, formatting, alignment, link and image commands) as a detached fragment. */
117
166
  static getDefaultDashboard(): DocumentFragment;
118
167
  /**
119
168
  * Seeks for a Selection' surrounding node of a given type and returns it, if any.
@@ -124,11 +173,37 @@ declare class ContenteditableUtils {
124
173
  static findSurroundingNode(node: Node, tagName: string): Element;
125
174
  static findSurroundingNode(range: Range, filter: (node: Node) => boolean): Element;
126
175
  static findSurroundingNode<TNode extends Node>(range: Range, type: Type<TNode>): TNode;
176
+ /**
177
+ * Seeks for the nearest surrounding block-level element of a given Selection's range.
178
+ * @param range
179
+ */
127
180
  static findSurroundingBlockElement(range: Range): Element;
181
+ /**
182
+ * Retrieves the sibling block-level elements (e.g. paragraphs) touched by a given Selection's range.
183
+ * @param range
184
+ */
128
185
  static findSurroundingSiblingBlockElements(range: Range): Element[];
186
+ /**
187
+ * Retrieves the top-level (direct children of the contenteditable root) elements spanned by a given Selection's range.
188
+ * @param range
189
+ */
129
190
  static findContainingRootElements(range: Range): Element[];
191
+ /**
192
+ * Checks whether the given node is an `Element` with a block-level (non-`inline*`) computed display.
193
+ * @param node
194
+ */
130
195
  static isBlockElement(node: Node): node is Element;
196
+ /**
197
+ * Selects a node (or its contents, when `inside` is `true`) and applies the resulting range to the current document Selection.
198
+ * @param node
199
+ * @param inside
200
+ */
131
201
  static select(node: Node, inside?: boolean): Range;
202
+ /**
203
+ * Copies all attributes from one element onto another.
204
+ * @param to
205
+ * @param from
206
+ */
132
207
  static copyAttributes(to: Element, from: Element): void;
133
208
  /**
134
209
  * Checks whether the provided range wraps an 'inert' (contentEditable=false) element, and returns result accordingly.
@@ -139,12 +214,15 @@ declare class ContenteditableUtils {
139
214
 
140
215
  declare const CONTENTELEMENT_BUTTONCOMMAND_TEMPLATE: string;
141
216
 
217
+ /** Form-field metadata derived from a single property of an OpenAPI/Swagger schema, with `props` recursively describing nested object properties. */
142
218
  declare interface DataField extends PropertyMetadata {
143
219
  props?: DataField[];
144
220
  }
145
221
 
222
+ /** An adapted, ready-to-render collection of {@link DataSourceItem}s. */
146
223
  declare type DataSource = DataSourceItem[];
147
224
 
225
+ /** Normalized shape a raw datasource entry is adapted into: the underlying `value`, its display text, whether it's disabled, and the original `data` it was built from. */
148
226
  declare type DataSourceItem = {
149
227
  value: any;
150
228
  viewValue: string;
@@ -152,10 +230,13 @@ declare type DataSourceItem = {
152
230
  data: any;
153
231
  };
154
232
 
233
+ /** Default map attribution string used by {@link PacemLatLngElement} when {@link LatLngOptions.attribution} isn't set (currently empty, i.e. the map adapter's own default applies). */
155
234
  declare const DEFAULT_ATTRIBUTION = "";
156
235
 
236
+ /** Default tile-layer URL template used by {@link PacemLatLngElement} when {@link LatLngOptions.tiles} isn't set (currently empty, i.e. the map adapter's own default applies). */
157
237
  declare const DEFAULT_TILES = "";
158
238
 
239
+ /** Declares a generated field's dependency on another property of the same entity: used to disable/hide the field, or to feed a value/parameter from the depended-on property. */
159
240
  declare type DependsOn = {
160
241
  prop: string;
161
242
  alias?: string;
@@ -168,6 +249,7 @@ declare type DependsOn = {
168
249
  hide?: boolean;
169
250
  };
170
251
 
252
+ /** Rendering-time output of a {@link PropertyMetadataDependsOnFactory}: the databinding expressions to plug into the generated field's disabled/hide/dependency-parameter attributes. */
171
253
  declare type DependsOnManifest = {
172
254
  disabledAttr: string;
173
255
  hideAttr?: string; /**@ dependency parameters */
@@ -176,14 +258,17 @@ declare type DependsOnManifest = {
176
258
  };
177
259
  };
178
260
 
261
+ /** Rendering-time output of a {@link PropertyMetadataDisplayCssClassFactory}: the databinding expression to plug into the generated field's `css-class` attribute. */
179
262
  declare type DisplayCssClassManifest = {
180
263
  cssClassAttr: string;
181
264
  };
182
265
 
266
+ /** Rendering-time output of a {@link PropertyMetadataDisplayCssFactory}: the databinding expression to plug into the generated field's `css` attribute. */
183
267
  declare type DisplayCssManifest = {
184
268
  cssAttr: string;
185
269
  };
186
270
 
271
+ /** Presentation options for a {@link PropertyMetadata}/{@link TypeMetadata}: label, description, formatting and styling of the auto-generated field. */
187
272
  declare type DisplayMetadata = {
188
273
  name?: string | PropertyMetadataLabelFactory;
189
274
  description?: string;
@@ -200,26 +285,34 @@ declare type DisplayMetadata = {
200
285
  icon?: string;
201
286
  };
202
287
 
288
+ /** Payload of an {@link ImageFetchRequestEvent}: an optional search hint plus paging (`skip`/`take`). */
203
289
  declare type FetchRequestEventArgs = {
204
290
  hint?: string;
205
291
  skip: number;
206
292
  take?: number;
207
293
  };
208
294
 
295
+ /** Dispatched by a scaffolding field (see `PacemBaseElement.changeHandler` in `types-components.ts`) whenever its `value` actually changes as a result of user interaction; bubbles so an ancestor {@link PacemFormElement}/`PacemFormFieldElement` can react to it. */
209
296
  declare class FieldChangeEvent extends CustomTypedEvent<FieldChangeEventArgs> {
210
297
  constructor(args: FieldChangeEventArgs);
211
298
  }
212
299
 
300
+ /** Detail payload of a {@link FieldChangeEvent}: which field changed and its old/new value. */
213
301
  declare interface FieldChangeEventArgs {
302
+ /** Name of the field that changed (matches {@link PacemBaseElement#name} on the scaffolding element that dispatched it, see `types-components.ts`). */
214
303
  fieldName: string;
304
+ /** The value the field had before this change. */
215
305
  oldValue?: any;
306
+ /** The value the field now has. */
216
307
  currentValue: any;
217
308
  /** Was the field in a pristine state before this change? */
218
309
  firstChange?: boolean;
219
310
  }
220
311
 
312
+ /** Event type name (`'change'`) dispatched as a {@link FieldChangeEvent}. */
221
313
  declare const FieldChangeEventName: string;
222
314
 
315
+ /** Rendering-time recipe for a generated field's markup: the element `tagName` to instantiate, its `attrs` (name to databinding-expression/literal), and any nested `children`. */
223
316
  declare type FieldManifest = {
224
317
  tagName: string;
225
318
  attrs?: {
@@ -228,10 +321,12 @@ declare type FieldManifest = {
228
321
  children?: FieldManifest[];
229
322
  };
230
323
 
324
+ /** Dispatched by {@link PacemUploadElement} whenever the user picks (or clears) file(s)/a directory. */
231
325
  declare class FileChangeEvent extends CustomTypedEvent<FileChangeEventArgs> {
232
326
  constructor(file: FileChangeEventArgs);
233
327
  }
234
328
 
329
+ /** Payload of a {@link FileChangeEvent}, reporting the newly selected file(s)/directory and whether the selection is valid. */
235
330
  declare type FileChangeEventArgs = {
236
331
  file?: File | FileSystemFileHandle;
237
332
  files?: File[] | FileSystemFileHandle[];
@@ -239,12 +334,15 @@ declare type FileChangeEventArgs = {
239
334
  valid: boolean;
240
335
  };
241
336
 
337
+ /** Name of the {@link FileChangeEvent} dispatched by {@link PacemUploadElement} whenever the selected file(s)/directory change. */
242
338
  declare const FileChangeEventName = "filechange";
243
339
 
340
+ /** Dispatched by {@link PacemUploadElement} to report chunked-upload progress/completion. */
244
341
  declare class FileUploadEvent extends CustomTypedEvent<FileUploadEventArgs> {
245
342
  constructor(file: FileUploadEventArgs);
246
343
  }
247
344
 
345
+ /** Payload of a {@link FileUploadEvent}, reporting the state of a chunked upload. */
248
346
  declare type FileUploadEventArgs = {
249
347
  complete: boolean;
250
348
  percentage: number;
@@ -254,22 +352,34 @@ declare type FileUploadEventArgs = {
254
352
  size: number;
255
353
  };
256
354
 
355
+ /** Name of the {@link FileUploadEvent} dispatched by {@link PacemUploadElement} while/after a chunked upload progresses. */
257
356
  declare const FileUploadEventName = "fileupload";
258
357
 
358
+ /**
359
+ * Listens on a {@link PacemEventTarget} (typically a {@link PacemFormElement}) for the events listed in
360
+ * {@link EMITTABLE_EVENT_TYPES} and pipes each through the target's `handle` method, additionally
361
+ * re-dispatching `command` events as a synthesized `'item' + commandName`-named `CustomEvent` (e.g.
362
+ * `itemdelete`, `itemselect`) so listeners can subscribe to the specific command they care about.
363
+ */
259
364
  declare class FormEventEmitter {
260
365
  private _element;
261
366
  constructor(_element: PacemEventTarget);
367
+ /** Starts listening for {@link EMITTABLE_EVENT_TYPES} on the target element. */
262
368
  start(): void;
263
369
  private _itemEmitHandler;
370
+ /** Stops listening for {@link EMITTABLE_EVENT_TYPES} on the target element. */
264
371
  stop(): void;
265
372
  }
266
373
 
374
+ /** Dispatched by {@link PacemFormElement} when the form is about to be reset (programmatically or via its generated reset button). Cancelable: calling `preventDefault()` aborts the reset, leaving fields as they were. */
267
375
  declare class FormResetEvent extends Event {
268
376
  constructor();
269
377
  }
270
378
 
379
+ /** Event type name (`'reset'`) dispatched as a {@link FormResetEvent}. */
271
380
  declare const FormResetEventName = "reset";
272
381
 
382
+ /** Namespace-like static helper for localizing form {@link TypeMetadata} (labels, watermarks, descriptions, validator error messages, command tooltips) against a translation dictionary. */
273
383
  declare class Forms {
274
384
  /**
275
385
  * Localizes the metadata of a form **in place** using a translation dictionary.
@@ -283,10 +393,17 @@ declare class Forms {
283
393
  private static _localizeMetadata;
284
394
  }
285
395
 
396
+ /**
397
+ * Dispatched by {@link PacemFormElement} right before a submission is actually sent to the server, once all
398
+ * fields have validated successfully. Cancelable: calling `preventDefault()` (or handling the event and
399
+ * returning `false`) aborts the submission before any request is made - useful to inject/transform
400
+ * {@link FormSubmitEventArgs#parameters} or veto the submit outright.
401
+ */
286
402
  declare class FormSubmitEvent extends CustomTypedEvent<FormSubmitEventArgs> {
287
403
  constructor(args: FormSubmitEventArgs);
288
404
  }
289
405
 
406
+ /** Detail payload of a {@link FormSubmitEvent}: the request `parameters` about to be sent, and a snapshot of all registered `fields` (own and sub-forms'), keyed by field name. */
290
407
  declare type FormSubmitEventArgs = {
291
408
  parameters: {
292
409
  [key: string]: any;
@@ -296,27 +413,39 @@ declare type FormSubmitEventArgs = {
296
413
  };
297
414
  };
298
415
 
416
+ /** Event type name (`'submit'`) dispatched as a {@link FormSubmitEvent}. */
299
417
  declare const FormSubmitEventName = "submit";
300
418
 
419
+ /**
420
+ * Resolves a `$ref` pointer (e.g. `#/definitions/Foo` or `#/components/schemas/Foo`) against an {@link ApiManifest}'s `definitions` map.
421
+ * @param manifest Manifest whose `definitions` are searched.
422
+ * @param $ref The `$ref` pointer to resolve.
423
+ * @returns The referenced definition's name and schema, or `null` if `$ref` doesn't match the expected pattern.
424
+ */
301
425
  declare function getOpenApiDefinition(manifest: ApiManifest, $ref: string): {
302
426
  name: string;
303
427
  schema: OpenApiSwagger.Schema;
304
428
  };
305
429
 
430
+ /** A flat collection of {@link HierarchyDataSourceItem}s making up a {@link PacemHierarchyElement}'s adapted datasource. */
306
431
  declare type HierarchyDataSource = HierarchyDataSourceItem[];
307
432
 
433
+ /** A {@link DataSourceItem} enriched with its resolved parent items, as used by {@link PacemHierarchyElement}. */
308
434
  declare type HierarchyDataSourceItem = DataSourceItem & {
309
435
  parents?: HierarchyDataSource;
310
436
  };
311
437
 
312
438
  declare type Icon = Components_4.Maps.Icon;
313
439
 
440
+ /** Dispatched to request a page of {@link Picture}s (e.g. on scroll, or when the search hint changes); handlers are expected to respond by setting `imageSet`. */
314
441
  declare class ImageFetchRequestEvent extends CustomTypedEvent<FetchRequestEventArgs> {
315
442
  constructor(args: FetchRequestEventArgs);
316
443
  }
317
444
 
445
+ /** Name of the {@link ImageFetchRequestEvent} dispatched by {@link PacemEditImageElement}/{@link PacemImageInputElement} to request a page of pictures. */
318
446
  declare const ImageFetchRequestEventName = "imagefetchrequest";
319
447
 
448
+ /** Well-known `document.execCommand` commands supported out-of-the-box by {@link PacemContenteditableExecCommandElement}. */
320
449
  declare enum KnownExecCommand {
321
450
  Bold = "bold",
322
451
  Italic = "italic",
@@ -330,6 +459,7 @@ declare enum KnownExecCommand {
330
459
  JustifyFull = "justifyFull"
331
460
  }
332
461
 
462
+ /** Discriminated union of the validator metadata shapes natively understood by the scaffolding engine, each mapping to one of the `p-*-validator` elements in `validators.ts`. */
333
463
  declare type KnownValidatorMetadata = {
334
464
  type: 'required';
335
465
  errorMessage: string;
@@ -393,18 +523,26 @@ export declare namespace L10n {
393
523
  }
394
524
  }
395
525
 
526
+ /** Rendering-time output of a {@link PropertyMetadataLabelFactory}: the databinding expression for the generated `<label>`'s content. */
396
527
  declare type LabelManifest = {
397
528
  contentAttr: string;
398
529
  };
399
530
 
531
+ /** Map-provider configuration consumed by {@link PacemLatLngElement}'s `options` property. */
400
532
  declare interface LatLngOptions {
533
+ /** Which map adapter to wire up: OpenStreetMap/Leaflet, Azure Maps, or Google Maps. */
401
534
  provider: 'osm' | 'leaflet' | 'azure' | 'google' | 'gmaps' | 'leafletjs';
535
+ /** Tile-layer URL template (Leaflet/OSM providers only). Falls back to {@link DEFAULT_TILES}. */
402
536
  tiles?: string;
537
+ /** Map attribution markup (Leaflet/OSM providers only). Falls back to {@link DEFAULT_ATTRIBUTION}. */
403
538
  attribution?: string;
539
+ /** API/subscription key required by the `azure` and `google`/`gmaps` providers. */
404
540
  apiKey?: string;
541
+ /** Marker icon to use, in the format expected by the underlying map adapter. */
405
542
  icon?: any;
406
543
  }
407
544
 
545
+ /** Pluggable replacement strategy used by {@link Forms.localizeMetadata} to resolve translated strings from a dictionary. */
408
546
  declare interface LocalizationOptions {
409
547
  /**
410
548
  * Translates the labels of a form field.
@@ -461,7 +599,14 @@ declare type OpenApi3Parameter = {
461
599
  schema: OpenApi3SchemaType;
462
600
  };
463
601
 
602
+ /** Parses an OpenAPI 3.x document into a format-agnostic {@link ApiManifest}, translating its `paths`/`components.schemas` into endpoints, resolved schema definitions and parameter types used to auto-generate form fields. */
464
603
  declare class OpenApi3Parser extends ApiParserBase {
604
+ /**
605
+ * Parses an OpenAPI 3.x document into an {@link ApiManifest}.
606
+ * @param content The OpenAPI 3.x document, either as a parsed object or as a JSON string.
607
+ * @param url Base url of the API, used as the manifest's `baseUrl`.
608
+ * @returns The parsed manifest, with endpoints and resolved schema definitions.
609
+ */
465
610
  parse(content: any, url?: string): ApiManifest;
466
611
  private _convertToApiParameters;
467
612
  private _translateType;
@@ -492,6 +637,7 @@ declare type OpenApi3Response = {
492
637
  };
493
638
  };
494
639
 
640
+ /** Root document shape of an OpenAPI 3.x specification, as consumed by {@link OpenApi3Parser}. */
495
641
  declare type OpenApi3Schema = {
496
642
  openapi: string;
497
643
  info?: {
@@ -553,13 +699,27 @@ declare type OpenApi3SimpleSchemaType = {
553
699
  default?: number;
554
700
  };
555
701
 
702
+ /** Format-detecting facade parser: inspects an API description document and delegates to {@link OpenApi3Parser} or {@link SwaggerParser} accordingly, producing a unified {@link ApiManifest} used to auto-generate form fields regardless of the source spec version. */
556
703
  declare class OpenApiParser extends ApiParserBase {
557
704
  private _openApi3;
558
705
  private _swagger;
559
706
  constructor(_openApi3?: OpenApi3Parser, _swagger?: SwaggerParser);
707
+ /**
708
+ * Parses `content` as either an OpenAPI 3.x or a Swagger (OpenAPI 2.0) document, dispatching on the presence of an `openapi` property.
709
+ * @param content The API description, either as a parsed object or as a JSON string.
710
+ * @param url Base url of the API, forwarded to the delegate parser to resolve/derive the manifest's `baseUrl`.
711
+ * @returns The parsed manifest.
712
+ */
560
713
  parse(content: any, url?: string): ApiManifest;
561
714
  }
562
715
 
716
+ /**
717
+ * Validates a field's (non-empty) value by calling a remote `url` (`p-async-validator`), sending it - along
718
+ * with any extra `parameters` - as a request parameter named after {@link PacemBaseValidatorElement#watch}.
719
+ * The response is considered valid when it is the literal text `'true'`, or a fetched JSON payload whose API
720
+ * result (see `Utils.getApiResult`) is truthy; anything else (including a failed fetch) is invalid.
721
+ * Debounces requests by 1 second and memoizes the last request/result to avoid redundant round-trips.
722
+ */
563
723
  declare class PacemAsyncValidatorElement extends PacemBaseValidatorElement implements Net.OAuthFetchable {
564
724
  #private;
565
725
  private _evaluateResult;
@@ -567,26 +727,49 @@ declare class PacemAsyncValidatorElement extends PacemBaseValidatorElement imple
567
727
  private _debouncer;
568
728
  private _deferredToken;
569
729
  evaluate(val: any): PromiseLike<boolean>;
730
+ /** Gets or sets extra parameters sent along with the field's value on each validation request. */
570
731
  parameters: any;
732
+ /** Gets or sets the credentials mode used for the validation fetch request. */
571
733
  fetchCredentials: RequestCredentials;
734
+ /** Gets or sets extra headers sent with the validation fetch request. */
572
735
  fetchHeaders: {
573
736
  [key: string]: string;
574
737
  };
738
+ /** Gets or sets the URL invoked to validate the field's value. */
575
739
  url: string;
740
+ /** Gets or sets the HTTP method used for the validation request. */
576
741
  method: Net.HttpMethod;
577
742
  private _fetcher;
578
743
  propertyChangedCallback(name: string, old: any, val: any, first?: boolean): void;
579
744
  }
580
745
 
746
+ /**
747
+ * Base class for editable form fields: it adds `required`/`autofocus`/`readonly`/`placeholder` state, focus
748
+ * and keyboard handling (Esc to revert, Enter submit prevention), and the plumbing that wires the
749
+ * `focus`/`blur`/`change`/`keydown`/`keyup` handlers onto whichever native {@link inputFields} a derived
750
+ * class exposes.
751
+ *
752
+ * Not extended directly by concrete fields either - see {@link PacemBaseInputElement} (in `input.ts`) for
753
+ * `<input>`/`<textarea>`-backed fields, and {@link PacemDataSourceElement} for datasource-driven ones
754
+ * (lists, selects, radio groups, ...).
755
+ */
581
756
  declare abstract class PacemBaseElement extends PacemModelElement {
582
757
  protected compareValuePropertyValues(old: any, val: any): boolean;
758
+ /** Gets or sets whether the field is required; reflected as the `pacem-required` CSS class and the `aria-required` attribute, and propagated to {@link inputFields}. */
583
759
  required: boolean;
760
+ /** Gets or sets whether the field should be focused automatically; propagated to {@link inputFields}. */
584
761
  autofocus: boolean;
762
+ /** Gets or sets whether the field is read-only; reflected as the `pacem-readonly` CSS class and triggers {@link toggleReadonlyView}. */
585
763
  readonly: boolean;
764
+ /** Gets or sets the field name used to register/bind against the owning {@link PacemFormElement}. */
586
765
  name: string;
766
+ /** Gets or sets the placeholder text; propagated to {@link inputFields}. */
587
767
  placeholder: string;
768
+ /** When implemented in a derived class, the native input element(s) this field wraps and forwards state/handlers to. */
588
769
  protected abstract get inputFields(): HTMLElement[];
770
+ /** When implemented in a derived class, must toggle whatever DOM/markup distinguishes the read-only presentation from the editable one. */
589
771
  protected abstract toggleReadonlyView(readonly: boolean): void;
772
+ /** @overridable Whether pressing Enter within this field should be prevented from submitting an ancestor form. Defaults to `false`. */
590
773
  protected get preventKeyboardSubmit(): boolean;
591
774
  /**
592
775
  * When implemented in a derived class, must handle the `UI -> value` change logic and returns the value that has been set.
@@ -612,14 +795,32 @@ declare abstract class PacemBaseElement extends PacemModelElement {
612
795
  blur(): void;
613
796
  }
614
797
 
798
+ /**
799
+ * Base class for fields backed by one or more native `<input>`/`<textarea>` elements ({@link inputField}):
800
+ * wires `input`/`focus` listeners onto them, applies `changePolicy`/`debounce` to decide when the native
801
+ * value is read back into {@link PacemModelElement#value} (via {@link getValue}), and optionally
802
+ * auto-selects the field's content on focus.
803
+ *
804
+ * Extended by {@link PacemOrdinalInputElement} (numeric/date-like inputs) and
805
+ * {@link PacemTextualInputElement} (text-like inputs); further specialized by the concrete `input-*.ts`
806
+ * elements in this package (e.g. text, number, date, password, ...).
807
+ */
615
808
  declare abstract class PacemBaseInputElement extends PacemBaseElement {
809
+ /** Gets or sets how long to wait, after the native input changes, before propagating the value: `false` (default, propagate on the next animation frame), `true` (propagate via `requestAnimationFrame`), or a number of milliseconds to debounce by. */
616
810
  debounce: number | boolean;
811
+ /** Gets or sets when the native input's value gets read back into {@link PacemModelElement#value}: on every `input` event, or only on `blur`. Defaults to {@link ChangePolicy.Input}. */
617
812
  changePolicy: ChangePolicy;
813
+ /** Gets or sets whether the native input's content should be automatically selected when it receives focus. */
618
814
  autoselect: boolean;
619
815
  propertyChangedCallback(name: string, old: any, val: any, first?: boolean): void;
620
816
  private _focusHandler;
621
817
  protected acceptValue(val: any): void;
818
+ /** @readonly Gets the first (usually only) native input element among {@link PacemBaseElement#inputFields}. */
622
819
  protected get inputField(): HTMLInputElement;
820
+ /**
821
+ * When implemented in a derived class, parses the native input's raw string value into the field's typed `value`.
822
+ * @param value Raw string value read off {@link inputField}
823
+ */
623
824
  protected abstract getValue(value: string): any;
624
825
  private _handle;
625
826
  protected onChange(evt?: Event): Promise<any>;
@@ -629,28 +830,50 @@ declare abstract class PacemBaseInputElement extends PacemBaseElement {
629
830
  disconnectedCallback(): void;
630
831
  }
631
832
 
833
+ /**
834
+ * Base class for all `p-*-validator` elements: registers/unregisters itself against the ancestor
835
+ * {@link PacemFormElement} field named by `watch`, and turns the abstract {@link evaluate} logic into the
836
+ * `Validator` contract's `validate` (short-circuiting to valid when `disabled`). Concrete validators only
837
+ * need to implement {@link evaluate}; the field's own error UI reads `invalid`/`errorMessage` off the
838
+ * element (see {@link BASIC_VALIDATOR_TEMPLATE}).
839
+ */
632
840
  declare abstract class PacemBaseValidatorElement extends PacemFormRelevantElement implements Validator {
633
841
  #private;
634
842
  constructor();
843
+ /** @readonly Gets whether the last validation run failed; toggles the `pacem-validator` element's error message visibility. */
635
844
  invalid: boolean;
845
+ /** Gets or sets the message displayed when the validator is `invalid`. */
636
846
  errorMessage: string;
847
+ /** Gets or sets the name of the field (registered on the ancestor {@link PacemFormElement}) this validator watches/validates. */
637
848
  watch: string;
638
849
  viewActivatedCallback(): void;
639
850
  propertyChangedCallback(name: string, old: any, val: any, first: boolean): void;
851
+ /** Asks the owning {@link PacemFormElement} to re-validate the watched field on the next animation frame; call after a configuration property (e.g. `min`/`max`/`pattern`) changes so the field re-evaluates against the new rule. */
640
852
  protected triggerFormFieldValidation(): void;
853
+ /** Validates `val` against this validator's rule; always resolves `true` (skips {@link evaluate}) when the validator is `disabled`. */
641
854
  validate(val: any): PromiseLike<boolean>;
855
+ /**
856
+ * When implemented in a derived class, applies this validator's specific rule to `val`.
857
+ * @param val Current value of the watched field
858
+ */
642
859
  protected abstract evaluate(val: any): PromiseLike<boolean>;
643
860
  }
644
861
 
862
+ /** Validates a {@link BinaryValue}/file-name (non-empty) upload against an optional filename `pattern` and/or `maxSize` in bytes (`p-binary-validator`). */
645
863
  declare class PacemBinaryValidatorElement extends PacemBaseValidatorElement {
864
+ /** Gets or sets a case-insensitive regular expression the uploaded file's name must match. */
646
865
  pattern: string | RegExp;
866
+ /** Gets or sets the maximum accepted file size, in bytes. */
647
867
  maxSize: number;
648
868
  propertyChangedCallback(name: string, old: any, val: any, first?: boolean): void;
649
869
  protected evaluate(val: string | BinaryValue): PromiseLike<boolean>;
650
870
  }
651
871
 
872
+ /** Utility 12-month grid picker, used internally by {@link PacemCalendarPickerElement} to pick a month within {@link viewYear}. */
652
873
  declare class PacemCalendarMonthPickerElement extends Components_2.PacemElement {
874
+ /** Gets or sets the currently selected month (as a `Date`, a date string, or a numeric timestamp). */
653
875
  month: Date | string | number;
876
+ /** Gets or sets the year the grid is currently displaying. */
654
877
  viewYear: number;
655
878
  propertyChangedCallback(name: string, old: any, val: any, first?: boolean): void;
656
879
  private _getMonthLabel;
@@ -659,6 +882,7 @@ declare class PacemCalendarMonthPickerElement extends Components_2.PacemElement
659
882
  private _setMonth;
660
883
  }
661
884
 
885
+ /** {@link PacemBaseInputElement}-alike field that pops up a `pacem-calendar` (with month/year zoom levels) to pick a `Date` value. */
662
886
  declare class PacemCalendarPickerElement extends PacemBaseElement {
663
887
  #private;
664
888
  private _input;
@@ -673,11 +897,17 @@ declare class PacemCalendarPickerElement extends PacemBaseElement {
673
897
  private _rangeLabel;
674
898
  private _dropdown;
675
899
  private _swiper;
900
+ /** Gets or sets the `Intl.DateTimeFormatOptions` (or a format string) used to render the read-only view value. */
676
901
  format: Intl.DateTimeFormatOptions | string;
902
+ /** Gets or sets the date ranges that cannot be selected on the calendar. */
677
903
  disabledRanges: Components_3.UI.DateRange[];
904
+ /** Gets or sets which day the week starts on. */
678
905
  weekStart: 'mon' | 'sun' | 'm' | 's' | 'monday' | 'sunday';
906
+ /** Gets or sets which picker is currently shown in the dropdown: the day calendar, the month grid, or the year grid. */
679
907
  viewmode: 'calendar' | 'month' | 'year';
908
+ /** Internal: the current calendar week's dates, two-way bound with the inner `pacem-calendar`. */
680
909
  private _week;
910
+ /** Internal: the date currently centered/viewed by the active picker (day, month, or year). */
681
911
  private _viewDate;
682
912
  propertyChangedCallback(name: string, old: any, val: any, first?: boolean): void;
683
913
  viewActivatedCallback(): void;
@@ -704,8 +934,11 @@ declare class PacemCalendarPickerElement extends PacemBaseElement {
704
934
  protected convertValueAttributeToProperty(attr: string): any;
705
935
  }
706
936
 
937
+ /** Utility grid picker of {@link YEARS_IN_RANGE} years, used internally by {@link PacemCalendarPickerElement} to pick a year within the range containing {@link viewYear}. */
707
938
  declare class PacemCalendarYearPickerElement extends Components_2.PacemElement {
939
+ /** Gets or sets the currently selected year (as a `Date`, a date string, or a numeric timestamp). */
708
940
  year: Date | string | number;
941
+ /** Gets or sets the year whose 12-years range is currently displayed. */
709
942
  viewYear: number;
710
943
  propertyChangedCallback(name: string, old: any, val: any, first?: boolean): void;
711
944
  private _getYearLabel;
@@ -714,17 +947,24 @@ declare class PacemCalendarYearPickerElement extends Components_2.PacemElement {
714
947
  private _setYear;
715
948
  }
716
949
 
950
+ /** Displays how many characters {@link string} contains, relative to {@link minlength}/{@link maxlength}, flagging validity via CSS class. */
717
951
  declare class PacemCharCountElement extends Components_2.PacemElement {
952
+ /** Gets or sets the minimum accepted length; the element is flagged invalid while {@link string} is shorter. */
718
953
  minlength: number;
954
+ /** Gets or sets the maximum accepted length; the element is flagged invalid while {@link string} is longer. */
719
955
  maxlength: number;
956
+ /** Gets or sets the text whose length is being counted. */
720
957
  string: string;
721
958
  private _isValid;
722
959
  private _length;
723
960
  }
724
961
 
962
+ /** {@link PacemBaseInputElement} rendering one single-character `<input>` per position (e.g. OTP/verification codes), joining them into a single string `value`. */
725
963
  declare class PacemCharsInputElement extends PacemBaseInputElement {
726
964
  #private;
965
+ /** Gets or sets how many single-character inputs to render. */
727
966
  charCount: number;
967
+ /** Gets or sets how the entered characters are transformed/displayed: as-is, forced to a case, or masked like a password. */
728
968
  inputTransform: 'uppercase' | 'lowercase' | 'password' | 'none';
729
969
  constructor();
730
970
  private redactViewValue;
@@ -751,6 +991,7 @@ declare class PacemCharsInputElement extends PacemBaseInputElement {
751
991
  protected get inputFields(): HTMLInputElement[];
752
992
  }
753
993
 
994
+ /** {@link PacemBaseElement}-based single checkbox field, mapping its checked state to {@link trueValue}/{@link falseValue}. */
754
995
  declare class PacemCheckboxElement extends PacemBaseElement {
755
996
  constructor();
756
997
  private _key;
@@ -758,9 +999,13 @@ declare class PacemCheckboxElement extends PacemBaseElement {
758
999
  private _checkbox;
759
1000
  private _label;
760
1001
  span: HTMLElement;
1002
+ /** Gets or sets the label displayed next to the checkbox (and used as the read-only view value when checked). */
761
1003
  caption: string;
1004
+ /** Gets or sets the `value` assigned when the checkbox is checked. */
762
1005
  trueValue: any;
1006
+ /** Gets or sets the `value` assigned when the checkbox is unchecked. */
763
1007
  falseValue: any;
1008
+ /** Gets or sets whether the checkbox is checked. */
764
1009
  selected: boolean;
765
1010
  protected toggleReadonlyView(readonly: boolean): void;
766
1011
  protected get inputFields(): HTMLInputElement[];
@@ -772,6 +1017,7 @@ declare class PacemCheckboxElement extends PacemBaseElement {
772
1017
  protected getViewValue(val: any): string;
773
1018
  }
774
1019
 
1020
+ /** Renders {@link PacemDataSourceElement#datasource} as a list of `pacem-checkbox` items, producing an array `value` of the checked items' mapped values. */
775
1021
  declare class PacemCheckboxListElement extends PacemDataSourceElement {
776
1022
  protected acceptValue(val: any): void;
777
1023
  constructor();
@@ -832,6 +1078,7 @@ declare class PacemChildFormPropagatorElement extends PacemEventTarget {
832
1078
  private _synchronize;
833
1079
  }
834
1080
 
1081
+ /** {@link PacemBaseElement}-based field pairing a native color picker with an alpha (0-100) slider, producing a hex/rgba color string `value`. */
835
1082
  declare class PacemColorInputElement extends PacemBaseElement {
836
1083
  protected acceptValue(val: any): void;
837
1084
  protected convertValueAttributeToProperty(attr: string): string;
@@ -848,31 +1095,42 @@ declare class PacemColorInputElement extends PacemBaseElement {
848
1095
  protected get inputFields(): HTMLInputElement[];
849
1096
  }
850
1097
 
1098
+ /** Validates a field's (non-empty) value against another (non-empty) value `to`, using the given comparison `operator` (`p-compare-validator`); dates are compared by their timestamp. */
851
1099
  declare class PacemCompareValidatorElement extends PacemBaseValidatorElement {
1100
+ /** Gets or sets the comparison operator to apply between the field's value and {@link to}. Defaults to equality when unset. */
852
1101
  operator: 'equal' | 'lessOrEqual' | 'less' | 'greater' | 'greaterOrEqual' | 'notEqual';
1102
+ /** Gets or sets the value (often databound to another field) to compare the watched field's value against. */
853
1103
  to: any;
854
1104
  propertyChangedCallback(name: string, old: any, val: any, first?: boolean): void;
855
1105
  private _prepareValuesForComparison;
856
1106
  evaluate(val: any): Promise<boolean>;
857
1107
  }
858
1108
 
1109
+ /** Toolbar button applying a text-alignment (left/center/right/justify) style to the block(s) touched by the current selection. */
859
1110
  declare class PacemContenteditableAlignCommandElement extends PacemContenteditableButtonCommandElement {
860
1111
  isRelevant(range: Range): boolean;
861
1112
  propertyChangedCallback(name: string, old: any, val: any, first?: boolean): void;
1113
+ /** Gets or sets the text alignment applied by this command. */
862
1114
  align: 'left' | 'right' | 'center' | 'justify';
863
1115
  exec(): Promise<void>;
864
1116
  }
865
1117
 
1118
+ /** Base class for the toolbar button-shaped contenteditable commands (bold, align, link, wrap, ...), sharing icon/shortcut/tooltip/active-state behavior. */
866
1119
  declare abstract class PacemContenteditableButtonCommandElement extends PacemContenteditableCommandElement {
1120
+ /** Gets or sets the material icon ligature displayed on the toolbar button. */
867
1121
  icon: string;
1122
+ /** Gets or sets the keyboard shortcut combination (e.g. `Ctrl+B`) that triggers the command. */
868
1123
  keyboardShortcut: string;
1124
+ /** Gets or sets the tooltip/alternate text describing the command. */
869
1125
  altText: string;
1126
+ /** Gets or sets whether the command is currently active (enabled and, when relevant, applied to the current selection). */
870
1127
  active: boolean;
871
1128
  cleanUp(_: HTMLElement): void;
872
1129
  propertyChangedCallback(name: string, old: any, val: any, first?: boolean): void;
873
1130
  protected getTooltip(altText?: string, shortcut?: string): string;
874
1131
  }
875
1132
 
1133
+ /** Base class for {@link PacemContenteditableElement} toolbar/command items, registered as {@link PacemItemElement} children of the editor. */
876
1134
  declare abstract class PacemContenteditableCommandElement extends PacemItemElement<PacemContenteditableElement> implements ContenteditableCommand {
877
1135
  abstract exec(...args: any[]): Promise<any>;
878
1136
  abstract isRelevant(range: Range): boolean;
@@ -885,21 +1143,26 @@ declare abstract class PacemContenteditableCommandElement extends PacemItemEleme
885
1143
  connectedCallback(): void;
886
1144
  viewActivatedCallback(): void;
887
1145
  disconnectedCallback(): void;
1146
+ /** Gets or sets the current selection range within the editor's content, mirrored from {@link PacemContenteditableElement#range}. */
888
1147
  protected range: Range;
1148
+ /** Gets or sets the editor's editable `<div>` element. */
889
1149
  protected contentElement: HTMLDivElement;
890
1150
  private _containerPropChangeHandler;
891
1151
  protected containerPropertyChangedCallback(name: string, old: any, val: any, first?: boolean): void;
892
1152
  }
893
1153
 
1154
+ /** Rich-text (`contenteditable`) field, hosting {@link PacemContenteditableCommandElement} toolbar commands and tracking an undo/redo {@link history}. */
894
1155
  declare class PacemContenteditableElement extends PacemItemsContainerBaseElement<PacemContenteditableCommandElement> {
895
1156
  #private;
896
1157
  constructor();
1158
+ /** @readonly Gets the undo/redo history service tracking this editor's HTML content. */
897
1159
  get history(): HistoryService<string>;
898
1160
  reset(): void;
899
1161
  private _fireHistoryChange;
900
1162
  protected convertValueAttributeToProperty(attr: string): string;
901
1163
  private _container;
902
1164
  private _dashboard;
1165
+ /** Gets or sets the current selection range within the editor's content. */
903
1166
  range: Range;
904
1167
  protected toggleReadonlyView(readonly: boolean): void;
905
1168
  register(item: PacemContenteditableCommandElement): boolean;
@@ -925,23 +1188,29 @@ declare class PacemContenteditableElement extends PacemItemsContainerBaseElement
925
1188
  protected getViewValue(val: any): any;
926
1189
  }
927
1190
 
1191
+ /** Toolbar button applying a native `document.execCommand`-backed formatting command (bold, italic, lists, ...) to the contenteditable host. */
928
1192
  declare class PacemContenteditableExecCommandElement extends PacemContenteditableButtonCommandElement {
929
1193
  private _matchRelevance;
930
1194
  isRelevant(range: Range): boolean;
1195
+ /** Gets or sets the `document.execCommand` command to apply. */
931
1196
  command: KnownExecCommand;
1197
+ /** Gets or sets the command's argument (e.g. the block tag name for `formatBlock`). */
932
1198
  argument: string;
933
1199
  propertyChangedCallback(name: string, old: any, val: any, first?: boolean): void;
934
1200
  exec(): Promise<void>;
935
1201
  }
936
1202
 
1203
+ /** Toolbar button undoing or redoing the last change tracked by the contenteditable host's history. */
937
1204
  declare class PacemContenteditableHistoryCommandElement extends PacemContenteditableButtonCommandElement {
938
1205
  exec(): Promise<any>;
939
1206
  isRelevant(_: Range): boolean;
1207
+ /** Gets or sets which history operation this button performs. */
940
1208
  command: 'undo' | 'redo';
941
1209
  propertyChangedCallback(name: string, old: any, val: any, first?: boolean): void;
942
1210
  protected containerPropertyChangedCallback(name: string, old: any, val: any, first?: boolean): void;
943
1211
  }
944
1212
 
1213
+ /** Toolbar button inserting a (rescalable) picture into the contenteditable host, either by file picker or by pasted/dropped image file. */
945
1214
  declare class PacemContenteditableImageCommandElement extends PacemContenteditableButtonCommandElement implements ContenteditableFileCommand {
946
1215
  #private;
947
1216
  pasteCallback(f: File): Promise<HTMLPictureElement>;
@@ -963,19 +1232,23 @@ declare class PacemContenteditableImageCommandElement extends PacemContenteditab
963
1232
  private _disposeContainer;
964
1233
  }
965
1234
 
1235
+ /** Toolbar button creating or removing a hyperlink (`<a>`) around the current selection. */
966
1236
  declare class PacemContenteditableLinkCommandElement extends PacemContenteditableButtonCommandElement {
967
1237
  isRelevant(range: Range): boolean;
1238
+ /** Gets or sets the `target` attribute (e.g. `_blank`) applied to newly created links. */
968
1239
  target: string;
969
1240
  viewActivatedCallback(): void;
970
1241
  exec(arg?: string, target?: string): Promise<void>;
971
1242
  }
972
1243
 
1244
+ /** Dropdown command inserting an inert (`contenteditable=false`) placeholder token, picked from a suggestable datasource, into the contenteditable host. */
973
1245
  declare class PacemContenteditablePlaceholderElement extends PacemContenteditableCommandElement {
974
1246
  #private;
975
1247
  private _itemtemplate;
976
1248
  private _dropdown;
977
1249
  cleanUp(content: HTMLElement): void;
978
1250
  exec(ph: string): Promise<any>;
1251
+ /** Gets or sets the available placeholders, either as plain strings or as `{ placeholder, definition }` entries. */
979
1252
  datasource: (string | {
980
1253
  placeholder: string;
981
1254
  definition?: string;
@@ -993,32 +1266,53 @@ declare class PacemContenteditablePlaceholderElement extends PacemContenteditabl
993
1266
  private _downgradePlaceholderElement;
994
1267
  }
995
1268
 
1269
+ /** Toolbar button wrapping (or, if already applied, unwrapping) the block(s) touched by the current selection with a given tag (e.g. `blockquote`, `h1`). */
996
1270
  declare class PacemContenteditableWrapCommandElement extends PacemContenteditableButtonCommandElement {
997
1271
  isRelevant(range: Range): boolean;
1272
+ /** Gets or sets the tag name (e.g. `blockquote`) this command wraps/unwraps the selection with. */
998
1273
  tagname: string;
999
1274
  exec(): Promise<void>;
1000
1275
  }
1001
1276
 
1277
+ /** Validates a field's (non-empty) value by deferring entirely to the externally-controlled {@link isValid} flag (`p-custom-validator`), for validation logic that doesn't fit the other built-in validators. */
1002
1278
  declare class PacemCustomValidatorElement extends PacemBaseValidatorElement {
1279
+ /** Gets or sets, from external logic, whether the watched field's current (non-empty) value should be considered valid. */
1003
1280
  isValid: boolean;
1004
1281
  propertyChangedCallback(name: string, old: any, val: any, first?: boolean): void;
1005
1282
  protected evaluate(val: any): PromiseLike<boolean>;
1006
1283
  }
1007
1284
 
1285
+ /** A single, declaratively-authored option (`<p-data-item>`) of a {@link PacemDataSourceElement}, as an alternative to a databound `datasource` array. */
1008
1286
  declare class PacemDataItemElement extends PacemItemElement<PacemDataSourceElement> {
1287
+ /** Gets or sets the option's value. The attribute is auto-coerced to boolean, number or `Date` when it parses as one, otherwise kept as a string. */
1009
1288
  value: any;
1289
+ /** Gets or sets the option's display label. Falls back to {@link value} when unset. */
1010
1290
  label: string;
1291
+ /** Gets or sets whether this option is disabled/unselectable. */
1011
1292
  disabled: boolean;
1012
1293
  }
1013
1294
 
1295
+ /**
1296
+ * Base class for datasource-driven selection fields (lists, dropdowns, radio/checkbox groups, autocomplete,
1297
+ * ...): adapts a raw `datasource` (an array of arbitrary entities, or declared {@link PacemDataItemElement}
1298
+ * children registered via {@link PacemItemsContainerBaseElement}) into a normalized {@link DataSource}, and
1299
+ * provides the value/view-value mapping and selection-matching logic (single or, when `multipleChoice` is
1300
+ * `true`, multi-select) that concrete subclasses build their UI on top of.
1301
+ */
1014
1302
  declare abstract class PacemDataSourceElement extends PacemItemsContainerBaseElement<PacemDataItemElement> {
1015
1303
  protected multipleChoice: boolean;
1016
1304
  constructor(multipleChoice?: boolean);
1305
+ /** Gets or sets the raw collection of entities to choose from. Ignored (and superseded) by registered {@link PacemDataItemElement} children, if any. */
1017
1306
  datasource: any[];
1307
+ /** Gets or sets the property name to read each entity's `value` from, when `datasource` entries are plain objects rather than {@link PacemDataItemElement}s. */
1018
1308
  valueProperty: string;
1309
+ /** Gets or sets the property name to read each entity's display text from, when `datasource` entries are plain objects rather than {@link PacemDataItemElement}s. */
1019
1310
  textProperty: string;
1311
+ /** Gets or sets the property name to read each entity's disabled flag from, when `datasource` entries are plain objects rather than {@link PacemDataItemElement}s. */
1020
1312
  disabledProperty: string;
1313
+ /** Gets or sets the property name used to compare complex (object) values against datasource entries when the plain value/reference doesn't match. */
1021
1314
  compareBy: string;
1315
+ /** @readonly Gets the current `datasource`, adapted into the normalized {@link DataSource} shape consumed by rendering. Recomputed by {@link databind}. */
1022
1316
  protected adaptedDatasource: DataSource;
1023
1317
  /**
1024
1318
  * Registers a new item among the items.
@@ -1031,8 +1325,11 @@ declare abstract class PacemDataSourceElement extends PacemItemsContainerBaseEle
1031
1325
  */
1032
1326
  unregister(item: PacemDataItemElement): boolean;
1033
1327
  private _itemPropertyChangedHandler;
1328
+ /** @overridable Maps a raw `datasource` array into its {@link DataSource} representation via {@link mapEntityToItem}. */
1034
1329
  protected buildAdaptedDatasource(ds?: any[]): DataSource;
1330
+ /** Recomputes {@link adaptedDatasource} and, if the current `value` no longer matches any item, calls {@link handleDatasourceMismatch}. Debounced. */
1035
1331
  protected databind(datasource?: DataSource): void;
1332
+ /** @overridable Called by {@link databind} when the current `value` matches none of the adapted `datasource` items. Defaults to clearing `value`. */
1036
1333
  protected handleDatasourceMismatch(datasource: DataSourceItem[]): void;
1037
1334
  /**
1038
1335
  * Checks wether the provided `item` matches the control's criteria for a selected option against a provided value (which defaults to control's value).
@@ -1046,8 +1343,11 @@ declare abstract class PacemDataSourceElement extends PacemItemsContainerBaseEle
1046
1343
  * @param value {any} value to match
1047
1344
  */
1048
1345
  protected isDataSourceItemSelected(item: DataSourceItem, value?: any): boolean;
1346
+ /** @overridable Extracts the selectable `value` out of a raw datasource entity (via {@link valueProperty}, or `entity.value` for a {@link PacemDataItemElement}). */
1049
1347
  protected mapEntityToValue(entity: any): any;
1348
+ /** @overridable Extracts the display text out of a raw datasource entity (via {@link textProperty}, or `entity.label`/`entity.value` for a {@link PacemDataItemElement}). */
1050
1349
  protected mapEntityToViewValue(entity: any): string;
1350
+ /** @overridable Adapts a raw datasource entity into its normalized {@link DataSourceItem} shape, using {@link mapEntityToValue}, {@link mapEntityToViewValue} and {@link disabledProperty}. */
1051
1351
  protected mapEntityToItem(entity: any): DataSourceItem;
1052
1352
  private _handle;
1053
1353
  private _handleItems;
@@ -1057,6 +1357,7 @@ declare abstract class PacemDataSourceElement extends PacemItemsContainerBaseEle
1057
1357
  protected compareValuePropertyValues(old: any, val: any): boolean;
1058
1358
  }
1059
1359
 
1360
+ /** {@link PacemBaseElement}-based field composing a set of `pacem-select` dropdowns (year/month/day and, depending on {@link precision}, time) into a single `Date` value. */
1060
1361
  declare class PacemDatetimePickerElement extends PacemBaseElement {
1061
1362
  constructor();
1062
1363
  private _yearel;
@@ -1069,25 +1370,38 @@ declare class PacemDatetimePickerElement extends PacemBaseElement {
1069
1370
  private _allFields;
1070
1371
  protected toggleReadonlyView(readonly: boolean): void;
1071
1372
  protected convertValueAttributeToProperty(attr: string): any;
1373
+ /** Gets or sets the composed `Date` value, kept in sync with the individual year/month/day/time selects. */
1072
1374
  dateValue: Date;
1375
+ /** Gets or sets the earliest selectable date; drives the lower bound of the year select. */
1073
1376
  min: string | Date;
1377
+ /** Gets or sets the latest selectable date; drives the upper bound of the year select. */
1074
1378
  max: string | Date;
1379
+ /** Gets or sets the granularity of the picker: date only, or including hours/minutes ('minute') or hours/minutes/seconds ('second'). */
1075
1380
  precision: 'day' | 'minute' | 'second';
1381
+ /** Gets or sets the `Intl.DateTimeFormatOptions` (or a format string) used to render the read-only/preview view value. */
1076
1382
  format: Intl.DateTimeFormatOptions | string;
1077
1383
  connectedCallback(): void;
1078
1384
  propertyChangedCallback(name: string, old: any, val: any, first?: boolean): void;
1079
1385
  protected acceptValue(val: any): void;
1080
1386
  private _disassembleDate;
1081
1387
  private _months;
1388
+ /** Internal: datasource of selectable days for the current {@link year}/{@link month}. */
1082
1389
  private _dates;
1083
1390
  private _a24;
1084
1391
  private _a60;
1392
+ /** Internal: datasource of selectable years, computed from {@link min}/{@link max}. */
1085
1393
  private _years;
1394
+ /** Internal: the year select's current value. */
1086
1395
  private year;
1396
+ /** Internal: the month select's current value. */
1087
1397
  private month;
1398
+ /** Internal: the day select's current value. */
1088
1399
  private date;
1400
+ /** Internal: the hours select's current value. */
1089
1401
  private hours;
1402
+ /** Internal: the minutes select's current value. */
1090
1403
  private minutes;
1404
+ /** Internal: the seconds select's current value. */
1091
1405
  private seconds;
1092
1406
  private _setupYears;
1093
1407
  protected onChange(evt?: Event): Promise<unknown>;
@@ -1097,6 +1411,10 @@ declare class PacemDatetimePickerElement extends PacemBaseElement {
1097
1411
  protected getViewValue(val: any): string;
1098
1412
  }
1099
1413
 
1414
+ /**
1415
+ * Picture-picker panel: lets the user search/browse a fetched {@link imageSet}, upload a new full-size/thumbnail pair, or take a
1416
+ * snapshot, resolving `value` to the chosen picture's source. Hosted inside a dialog by {@link PacemImageInputElement}.
1417
+ */
1100
1418
  declare class PacemEditImageElement extends Components_2.PacemElement {
1101
1419
  private _uploaderPropertyChangedCallback;
1102
1420
  private _thumbnailUploaderPropertyChangedCallback;
@@ -1105,17 +1423,28 @@ declare class PacemEditImageElement extends Components_2.PacemElement {
1105
1423
  private _snapshotPropertyChangedCallback;
1106
1424
  reset(): void;
1107
1425
  propertyChangedCallback(name: string, old: any, val: any, first?: boolean): void;
1426
+ /** Gets or sets the endpoint pictures are uploaded to (and used to build the upload/thumbnail-upload elements). */
1108
1427
  uploadUrl: string;
1109
1428
  private _index;
1429
+ /** Gets or sets the search hint typed by the user, triggering a fresh {@link ImageFetchRequestEvent} when it changes. */
1110
1430
  hint: string;
1431
+ /** Gets or sets the (paged) set of pictures to browse, typically supplied in response to an {@link ImageFetchRequestEvent}. */
1111
1432
  imageSet: PictureSet;
1433
+ /** Gets or sets the currently selected picture's source. */
1112
1434
  value: string;
1435
+ /** Gets or sets the max width (in pixels) an uploaded full-size image is resized to. */
1113
1436
  maxWidth: number;
1437
+ /** Gets or sets the max height (in pixels) an uploaded full-size image is resized to. */
1114
1438
  maxHeight: number;
1439
+ /** Gets or sets the max width (in pixels) an uploaded thumbnail is resized to. */
1115
1440
  maxThumbnailWidth: number;
1441
+ /** Gets or sets the max height (in pixels) an uploaded thumbnail is resized to. */
1116
1442
  maxThumbnailHeight: number;
1443
+ /** Gets or sets whether taking a snapshot (e.g. via webcam) is offered as an alternative to uploading. */
1117
1444
  allowSnapshot: boolean;
1445
+ /** Internal: whether a page of {@link imageSet} is currently being fetched. */
1118
1446
  private _fetching;
1447
+ /** Internal: the flattened list of pictures rendered by the repeater, kept in sync with {@link imageSet}. */
1119
1448
  private _images;
1120
1449
  private _repeater;
1121
1450
  private _uploader;
@@ -1126,22 +1455,37 @@ declare class PacemEditImageElement extends Components_2.PacemElement {
1126
1455
  private _imagefetch;
1127
1456
  }
1128
1457
 
1458
+ /** {@link PacemTextualInputElement} for an `<input type="email">`, whose read-only view renders as a `mailto:` link. */
1129
1459
  declare class PacemEmailInputElement extends PacemTextualInputElement {
1130
- input: HTMLInputElement;
1131
- anchor: Components_3.UI.PacemAnchorElement;
1460
+ private _input;
1461
+ private _anchor;
1132
1462
  protected toggleReadonlyView(readonly: boolean): void;
1133
1463
  protected get inputFields(): HTMLInputElement[];
1134
1464
  }
1135
1465
 
1466
+ /**
1467
+ * `<p-form>`: the scaffolding package's central form element. Aggregates the validity/dirty state of its
1468
+ * registered fields ({@link registerField}) and validators ({@link registerValidator}), of any nested
1469
+ * sub-forms ({@link registerSubForm} - e.g. from a {@link Pacem.Components.Scaffolding.PacemChildFormElement}
1470
+ * in `childform.ts`), drives submission ({@link submit}) and reset ({@link reset}), and - when `autogenerate`
1471
+ * is `true` and `metadata` is provided - builds its own field markup from a {@link TypeMetadata}/
1472
+ * {@link PropertyMetadata} description instead of requiring hand-authored markup.
1473
+ */
1136
1474
  declare class PacemFormElement extends PacemFormRelevantElement implements Net.OAuthFetchable {
1137
1475
  #private;
1476
+ /** Gets or sets an explicit fetcher to submit through, in place of the auto-generated one (only relevant when `autogenerate` is used, or the fetcher is otherwise supplied to {@link submit}). */
1138
1477
  fetcher: Components_2.PacemFetchElement;
1478
+ /** Gets or sets the credentials mode used by the auto-generated fetcher. */
1139
1479
  fetchCredentials: RequestCredentials;
1480
+ /** Gets or sets extra headers sent by the auto-generated fetcher. */
1140
1481
  fetchHeaders: {
1141
1482
  [key: string]: string;
1142
1483
  };
1484
+ /** Gets or sets the HTTP method used by the auto-generated fetcher. Defaults to `POST`. */
1143
1485
  method: Net.HttpMethod;
1486
+ /** Gets or sets the caption of the auto-generated submit button. Defaults to `'OK'` when unset. */
1144
1487
  submitCaption: string;
1488
+ /** Gets or sets the caption of the auto-generated reset button. Defaults to `'Reset'` when unset. */
1145
1489
  resetCaption: string;
1146
1490
  private _emitter;
1147
1491
  constructor();
@@ -1155,6 +1499,7 @@ declare class PacemFormElement extends PacemFormRelevantElement implements Net.O
1155
1499
  submit: Element;
1156
1500
  reset: Element;
1157
1501
  };
1502
+ /** @readonly Gets whether a submission is currently in flight; also reflected as the `pacem-fetching` CSS class. */
1158
1503
  get fetching(): boolean;
1159
1504
  private _keyupHandler;
1160
1505
  private _submit;
@@ -1183,35 +1528,84 @@ declare class PacemFormElement extends PacemFormRelevantElement implements Net.O
1183
1528
  private _fieldPropertyChanged;
1184
1529
  private _validatorPropertyChanged;
1185
1530
  private _checkFieldValidity;
1531
+ /**
1532
+ * Validates a single named field, or - when `name` is omitted - every field of this form and its
1533
+ * sub-forms, running each field's registered validators and updating their `valid`/`invalid` state.
1534
+ * @param name Optional name of a single field to validate; validates the whole form (recursively) when omitted.
1535
+ */
1186
1536
  validate(name?: string): PromiseLike<boolean>;
1187
1537
  private _validateAllFields;
1188
1538
  private _validateField;
1189
1539
  private _checkDirtyness;
1190
1540
  private _checkValidity;
1541
+ /**
1542
+ * Registers a nested {@link PacemFormElement} (e.g. rendered by a `PacemChildFormElement`, see
1543
+ * `childform.ts`) so its fields' validity/dirtyness roll up into this form's own {@link valid}/{@link dirty}.
1544
+ * @param form Sub-form to enroll
1545
+ */
1191
1546
  registerSubForm(form: PacemFormElement): void;
1547
+ /**
1548
+ * Removes a previously-registered nested form; its fields no longer influence this form's {@link valid}/{@link dirty}.
1549
+ * @param form Sub-form to remove
1550
+ */
1192
1551
  unregisterSubForm(form: PacemFormElement): void;
1552
+ /**
1553
+ * Registers a field's {@link PacemModel} under `name`, so it is included in submission ({@link FormSubmitEventArgs#fields}), validation, dirty/valid roll-up and reset. Typically called by the field itself (see `PacemModelElement._registerFieldConditionally` in `types-components.ts`) rather than directly.
1554
+ * @param name Field name to register under
1555
+ * @param model Field implementing {@link PacemModel}
1556
+ */
1193
1557
  registerField(name: string, model: PacemModel): void;
1558
+ /**
1559
+ * Removes a previously-registered field.
1560
+ * @param name Field name to remove
1561
+ * @param check Whether to re-check the form's overall validity/dirtyness afterwards (default `true`)
1562
+ */
1194
1563
  unregisterField(name: string, check?: boolean): void;
1564
+ /**
1565
+ * Registers a {@link Validator} (typically a {@link PacemBaseValidatorElement}) against the named field, so it participates in that field's validation. Typically called by the validator itself rather than directly.
1566
+ * @param name Name of the field being validated
1567
+ * @param validator Validator to enroll
1568
+ */
1195
1569
  registerValidator(name: string, validator: Validator): void;
1570
+ /**
1571
+ * Removes a previously-registered validator from the named field.
1572
+ * @param name Name of the field the validator was registered against
1573
+ * @param validator Validator to remove
1574
+ */
1196
1575
  unregisterValidator(name: string, validator: Validator): void;
1197
1576
  private _unregisterValidator;
1577
+ /** @readonly Gets whether every registered field and sub-form currently passes validation. Recomputed on field/sub-form registration and whenever a field's/sub-form's `valid` state changes. */
1198
1578
  valid: boolean;
1579
+ /** @readonly Gets whether any registered field or sub-form is currently dirty. Recomputed on field/sub-form registration and whenever a field's/sub-form's `dirty` state changes. */
1199
1580
  dirty: boolean;
1581
+ /** Gets or sets whether the form (and, when `autogenerate`d, its generated fields) is read-only. */
1200
1582
  readonly: boolean;
1583
+ /** @readonly Gets whether the last submission completed successfully. */
1201
1584
  success: boolean;
1585
+ /** @readonly Gets whether the last submission failed. */
1202
1586
  fail: boolean;
1587
+ /** Gets or sets the entity being edited; fields typically two-way bind their `value` against one of its properties. */
1203
1588
  entity: any;
1589
+ /** Gets or sets the property name to nest {@link entity} under in the submitted request payload. When unset, `entity` is submitted as the whole payload. */
1204
1590
  entityName: string;
1591
+ /** Gets or sets the metadata describing {@link entity}'s type (or its properties directly, as a `PropertyMetadata[]`), used to auto-generate the form's fields when `autogenerate` is `true`. */
1205
1592
  metadata: TypeMetadata | PropertyMetadata[];
1593
+ /** Gets or sets whether the form should build its own field markup from `metadata` instead of requiring hand-authored child markup. */
1206
1594
  autogenerate: boolean;
1207
1595
  /** Gets or sets whether to hint invalid fields even if still pristine (default 'true').
1208
1596
  * When 'true' - and form is autogenerated - the submit button status is tightly bound to the form valid state. */
1209
1597
  suddenValidation: boolean;
1210
1598
  /** Gets or sets whether the form should show - when autogenerated - the reset button. */
1211
1599
  resettable: boolean;
1600
+ /** Gets or sets the URL the auto-generated fetcher submits to. Ignored when an explicit `fetcher` is set, or the form isn't `autogenerate`d. */
1212
1601
  action: string;
1213
1602
  }
1214
1603
 
1604
+ /**
1605
+ * Renders a single editing field (label, input, validators, tooltip) for {@link entity}'s property described by {@link metadata},
1606
+ * dynamically choosing and building up the concrete input element (e.g. `pacem-input-text`, `pacem-select`, `pacem-checkbox`, ...)
1607
+ * based on the metadata's `dataType`/`ui` hints. Used internally by `pacem-form` for autogenerated forms.
1608
+ */
1215
1609
  declare class PacemFormFieldElement extends PacemFormRelevantElement implements Net.OAuthFetchable {
1216
1610
  private _md;
1217
1611
  constructor(_md?: Components_3.UI.MarkdownService);
@@ -1223,15 +1617,23 @@ declare class PacemFormFieldElement extends PacemFormRelevantElement implements
1223
1617
  private _fetcher;
1224
1618
  private _form;
1225
1619
  private _validators;
1620
+ /** @readonly Gets this field's unique key, used to derive DOM ids for the label/input/fetcher. */
1226
1621
  get key(): string;
1622
+ /** @readonly Gets the inner `pacem-fetch` element used to retrieve remotely-sourced datasources for this field. */
1227
1623
  get fetcher(): Net.Fetcher;
1624
+ /** Gets or sets the metadata describing the entity property being edited (data type, validators, UI hints, ...). */
1228
1625
  metadata: PropertyMetadata;
1626
+ /** Gets or sets the extra headers sent along with any fetch requests (datasource, async validation) issued by this field. */
1229
1627
  fetchHeaders: {
1230
1628
  [key: string]: string;
1231
1629
  };
1630
+ /** Gets or sets the credentials mode used for fetch requests issued by this field. */
1232
1631
  fetchCredentials: RequestCredentials;
1632
+ /** Gets or sets whether the field is read-only. */
1233
1633
  readonly: boolean;
1634
+ /** Gets or sets the entity instance (or `HTMLElement`) whose {@link metadata}-described property this field edits. */
1234
1635
  entity: any;
1636
+ /** @readonly Gets the concrete input element built for this field (e.g. `pacem-input-text`, `pacem-select`, ...). */
1235
1637
  get field(): HTMLElement;
1236
1638
  viewActivatedCallback(): void;
1237
1639
  propertyChangedCallback(name: string, old?: any, val?: any, first?: boolean): void;
@@ -1259,6 +1661,7 @@ declare class PacemFormFieldElement extends PacemFormRelevantElement implements
1259
1661
  private _buildUpField;
1260
1662
  }
1261
1663
 
1664
+ /** Minimal contract shared by anything that can be registered against a {@link PacemFormElement} as either a field or a validator: dirty/valid state, a `name` to register under, and the owning `form`. */
1262
1665
  declare interface PacemFormOrField {
1263
1666
  dirty: boolean;
1264
1667
  valid: boolean;
@@ -1268,11 +1671,14 @@ declare interface PacemFormOrField {
1268
1671
  setDirty(): void;
1269
1672
  }
1270
1673
 
1674
+ /** Base class for elements that need a reference to their closest ancestor {@link PacemFormElement} (form fields, validators): resolves and exposes it as {@link form} on activation. */
1271
1675
  declare abstract class PacemFormRelevantElement extends Components_2.PacemElement {
1676
+ /** @readonly Gets the closest ancestor {@link PacemFormElement}, resolved on activation. */
1272
1677
  form: PacemFormElement;
1273
1678
  viewActivatedCallback(): void;
1274
1679
  }
1275
1680
 
1681
+ /** {@link PacemBaseElement}-based field pairing an address `pacem-suggest` (forward geocoding) with a draggable map marker (reverse geocoding) to pick an {@link Address}. */
1276
1682
  declare class PacemGeolocateElement extends PacemBaseElement {
1277
1683
  #private;
1278
1684
  protected get inputFields(): HTMLElement[];
@@ -1283,8 +1689,11 @@ declare class PacemGeolocateElement extends PacemBaseElement {
1283
1689
  protected acceptValue(val: Address): void;
1284
1690
  protected getViewValue(value: Address): string;
1285
1691
  protected convertValueAttributeToProperty(attr: string): any;
1692
+ /** Gets or sets the map adapter used by the internal geocoders (forwarded to `pacem-map-geocode`). */
1286
1693
  adapter: Components_4.Maps.PacemMapAdapterElement;
1694
+ /** Gets or sets the map onto which the draggable position marker is attached. */
1287
1695
  map: Components_4.Maps.PacemMapElement;
1696
+ /** Gets or sets the icon used for the position marker. */
1288
1697
  icon: string | Icon;
1289
1698
  private _datasource;
1290
1699
  private _suggest;
@@ -1303,13 +1712,18 @@ declare class PacemGeolocateElement extends PacemBaseElement {
1303
1712
  private _setup;
1304
1713
  }
1305
1714
 
1715
+ /** {@link PacemTextualInputElement} wrapping an `<input type="hidden">`, for values that must round-trip without a visible UI. */
1306
1716
  declare class PacemHiddenInputElement extends PacemTextualInputElement {
1307
1717
  constructor();
1308
- input: HTMLInputElement;
1718
+ private _input;
1309
1719
  protected toggleReadonlyView(readonly: boolean): void;
1310
1720
  protected get inputFields(): HTMLInputElement[];
1311
1721
  }
1312
1722
 
1723
+ /**
1724
+ * {@link PacemBaseElement}-based field for editing a DAG-like parent/child hierarchy over {@link datasource}: items are
1725
+ * arranged level-by-level and linked/unlinked via drag-drop, producing an array `value` of `{ [valueProperty]: any, parents: any[] }`.
1726
+ */
1313
1727
  declare class PacemHierarchyElement extends PacemBaseElement {
1314
1728
  #private;
1315
1729
  protected getViewValue(value: any): string;
@@ -1321,16 +1735,23 @@ declare class PacemHierarchyElement extends PacemBaseElement {
1321
1735
  private _dragger;
1322
1736
  private _dragger2;
1323
1737
  private _shellProxy;
1738
+ /** Gets or sets the raw collection of entities to arrange into a hierarchy. */
1324
1739
  datasource: any[];
1740
+ /** Gets or sets the name of the entity property used as each item's unique value. */
1325
1741
  valueProperty: string;
1742
+ /** Gets or sets the name of the entity property used as each item's display text. */
1326
1743
  textProperty: string;
1744
+ /** Gets or sets the name of the entity property that flags an item as disabled (non-draggable/non-linkable). */
1327
1745
  disabledProperty: string;
1746
+ /** Gets or sets the caption of the balloon button used to unlink a parent/child relation. */
1328
1747
  unlinkCaption: string;
1748
+ /** Internal: {@link datasource} mapped into {@link DataSourceItem}s. */
1329
1749
  private _adaptedDatasource;
1750
+ /** Gets or sets a custom template used to render each hierarchy item; falls back to the default template when unset. */
1330
1751
  itemtemplate: HTMLTemplateElement;
1752
+ /** Internal: the resolved (custom or default) item template currently in use. */
1331
1753
  private _template;
1332
- /**
1333
- * */
1754
+ /** Gets or sets the name of the entity property holding an item's array of parent values; defaults to `'parents'`. */
1334
1755
  parentsProperty: string;
1335
1756
  protected get inputFields(): HTMLElement[];
1336
1757
  protected toggleReadonlyView(readonly: boolean): void;
@@ -1371,6 +1792,10 @@ declare class PacemHierarchyElement extends PacemBaseElement {
1371
1792
  private _databindByParents;
1372
1793
  }
1373
1794
 
1795
+ /**
1796
+ * {@link PacemBaseElement}-based field showing an image preview with edit/clear buttons; editing opens a dialog hosting a
1797
+ * {@link PacemEditImageElement} to pick/upload/snapshot a new picture, while `value` also accepts a directly-typed URL.
1798
+ */
1374
1799
  declare class PacemImageInputElement extends PacemBaseElement {
1375
1800
  protected convertValueAttributeToProperty(attr: string): string;
1376
1801
  private _editImage;
@@ -1397,25 +1822,45 @@ declare class PacemImageInputElement extends PacemBaseElement {
1397
1822
  private _update;
1398
1823
  private _retrieve;
1399
1824
  _edit(evt: Event): void;
1825
+ /** Gets or sets the endpoint pictures are uploaded to; forwarded to the {@link PacemEditImageElement} dialog. */
1400
1826
  uploadUrl: string;
1827
+ /** Gets or sets the (paged) set of pictures offered to browse; forwarded to the {@link PacemEditImageElement} dialog. */
1401
1828
  imageSet: PictureSet;
1829
+ /** Gets or sets the max width (in pixels) an uploaded full-size image is resized to. */
1402
1830
  maxWidth: number;
1831
+ /** Gets or sets the max height (in pixels) an uploaded full-size image is resized to. */
1403
1832
  maxHeight: number;
1833
+ /** Gets or sets the max width (in pixels) an uploaded thumbnail is resized to. */
1404
1834
  maxThumbnailWidth: number;
1835
+ /** Gets or sets the max height (in pixels) an uploaded thumbnail is resized to. */
1405
1836
  maxThumbnailHeight: number;
1837
+ /** Gets or sets whether taking a snapshot is offered as an alternative to uploading. */
1406
1838
  allowSnapshot: boolean;
1407
1839
  }
1408
1840
 
1841
+ /**
1842
+ * Scaffolding-specific counterpart of `@pacem/pacem-ui`'s `PacemItemElement`: a base class for elements that
1843
+ * register themselves against an ancestor {@link PacemItemsContainerBaseElement} (found via
1844
+ * {@link findContainer}) on activation, and unregister on disconnect. Extended by {@link PacemDataItemElement}.
1845
+ */
1409
1846
  declare abstract class PacemItemElement<TContainer extends PacemItemsContainerBaseElement<any>> extends Components_2.PacemElement {
1410
1847
  #private;
1411
- /** @overridable */
1848
+ /** @overridable Locates the ancestor items-container this item registers against. Defaults to the nearest {@link PacemItemsContainerBaseElement}. */
1412
1849
  protected findContainer(): TContainer;
1850
+ /** @readonly Gets the items-container this item is currently registered with, if any. */
1413
1851
  protected get container(): TContainer;
1414
1852
  viewActivatedCallback(): void;
1415
1853
  disconnectedCallback(): void;
1416
1854
  }
1417
1855
 
1856
+ /**
1857
+ * Base class for form fields that also act as a registry of {@link PacemItemElement} children (e.g. a
1858
+ * datasource-backed selection field whose options are declared, not just databound). Combines
1859
+ * {@link PacemBaseElement}'s field behavior with `ItemsContainer<TItem>`'s registration API.
1860
+ * See {@link PacemDataSourceElement} for the concrete specialization holding {@link PacemDataItemElement}s.
1861
+ */
1418
1862
  declare abstract class PacemItemsContainerBaseElement<TItem extends HTMLElement> extends PacemBaseElement implements ItemsContainer<TItem> {
1863
+ /** Gets the currently registered items. Read-only in practice: only ever set by {@link register}/{@link unregister} or two-way databinding. */
1419
1864
  items: TItem[];
1420
1865
  /**
1421
1866
  * Registers a new item among the items.
@@ -1429,6 +1874,7 @@ declare abstract class PacemItemsContainerBaseElement<TItem extends HTMLElement>
1429
1874
  unregister(item: TItem): boolean;
1430
1875
  }
1431
1876
 
1877
+ /** A `<p-latlng>` field: a {@link PacemBaseElement} coordinate picker combining paired lat/lng number inputs with an interactive, draggable-marker map (Leaflet/OSM, Azure Maps or Google Maps) and reverse-geocoded address preview. */
1432
1878
  declare class PacemLatLngElement extends PacemBaseElement {
1433
1879
  protected convertValueAttributeToProperty(attr: string): {
1434
1880
  lat: number;
@@ -1454,24 +1900,33 @@ declare class PacemLatLngElement extends PacemBaseElement {
1454
1900
  private _lngInput;
1455
1901
  private _inputContainer;
1456
1902
  private _fetcher;
1903
+ /** Gets or sets the map-provider configuration. Re-synchronizes the map adapter/marker whenever assigned. */
1457
1904
  options: LatLngOptions;
1905
+ /** Internal latitude, mirrored to/from the paired lat/lng number inputs and the marker's position. */
1458
1906
  private _lat;
1907
+ /** Internal longitude, mirrored to/from the paired lat/lng number inputs and the marker's position. */
1459
1908
  private _lng;
1460
1909
  }
1461
1910
 
1911
+ /** Validates that a field's (non-empty) value's string length falls within `[min, max]` (`p-length-validator`). */
1462
1912
  declare class PacemLengthValidatorElement extends PacemBaseValidatorElement {
1913
+ /** Gets or sets the minimum accepted string length (inclusive). Unset/negative disables the lower bound. */
1463
1914
  min: number;
1915
+ /** Gets or sets the maximum accepted string length (inclusive). Unset/negative disables the upper bound. */
1464
1916
  max: number;
1465
1917
  propertyChangedCallback(name: string, old: any, val: any, first?: boolean): void;
1466
1918
  evaluate(val: any): Promise<boolean>;
1467
1919
  }
1468
1920
 
1921
+ /** A `<p-textarea-markdown>` field: a {@link PacemTextualInputElement} backed by a native `<textarea>` for editing Markdown text, whose readonly view renders the value as HTML via {@link Components.UI.MarkdownService}. */
1469
1922
  declare class PacemMarkdownTextAreaElement extends PacemTextualInputElement {
1470
1923
  private _md;
1471
1924
  constructor(_md?: Components_3.UI.MarkdownService);
1925
+ /** Gets or sets the native `<textarea>`'s `rows` attribute. Defaults to `5`. */
1472
1926
  rows: number;
1927
+ /** Gets or sets the native `<textarea>`'s `cols` attribute. Defaults to `50`. */
1473
1928
  cols: number;
1474
- input: HTMLTextAreaElement;
1929
+ private _input;
1475
1930
  private _markdown;
1476
1931
  protected toggleReadonlyView(readonly: boolean): void;
1477
1932
  /** @override */
@@ -1484,32 +1939,61 @@ declare class PacemMarkdownTextAreaElement extends PacemTextualInputElement {
1484
1939
  private _keydownHandler;
1485
1940
  }
1486
1941
 
1942
+ /** Contract for a form field: a {@link PacemFormOrField} that additionally carries a `value`/`viewValue` pair and can be reset to its original value. Implemented by {@link PacemModelElement}. */
1487
1943
  declare interface PacemModel extends PacemFormOrField {
1488
1944
  value: any;
1489
1945
  viewValue: string;
1490
1946
  reset(): void;
1491
1947
  }
1492
1948
 
1949
+ /**
1950
+ * Base class for any element that behaves as a bindable, form-aware model value: it registers itself by
1951
+ * `name` with the ancestor {@link PacemFormElement} (found via {@link PacemFormRelevantElement}), tracks
1952
+ * `dirty`/`valid` state (reflected as `pacem-dirty`/`pacem-invalid` CSS classes), and remembers the value it
1953
+ * had when activated/set-pristine so {@link reset} can restore it.
1954
+ *
1955
+ * Concrete input/selection fields don't extend this directly - see {@link PacemBaseElement}, the abstract
1956
+ * subclass that adds readonly/required/focus/keyboard handling on top of it.
1957
+ */
1493
1958
  declare abstract class PacemModelElement extends PacemFormRelevantElement implements PacemModel {
1494
1959
  viewActivatedCallback(): void;
1495
1960
  private _registerFieldConditionally;
1496
1961
  propertyChangedCallback(name: string, old: any, val: any, first: boolean): void;
1497
1962
  disconnectedCallback(): void;
1963
+ /** @readonly The `value` this element had the last time it was activated or explicitly marked pristine (via {@link setPristine}); what {@link reset} restores. */
1498
1964
  protected get originalValue(): any;
1499
1965
  private _setAsOriginalValue;
1966
+ /**
1967
+ * When implemented in a derived class, computes the human-readable {@link viewValue} to display for a given `value`.
1968
+ * @param value Current value
1969
+ */
1500
1970
  protected abstract getViewValue(value: any): string;
1971
+ /** Restores {@link value} to {@link originalValue} and clears {@link dirty}. */
1501
1972
  reset(): void;
1973
+ /** Marks the current `value` as the new baseline for {@link reset}/{@link originalValue} and clears {@link dirty}. */
1502
1974
  setPristine(): void;
1975
+ /** Marks this field as `dirty`. */
1503
1976
  setDirty(): void;
1977
+ /**
1978
+ * When implemented in a derived class, parses the `value` attribute's string representation into the typed property value.
1979
+ * @param attr Raw attribute string
1980
+ */
1504
1981
  protected abstract convertValueAttributeToProperty(attr: string): any;
1982
+ /** When implemented in a derived class, determines whether two `value`s are equal (used to decide whether a change actually occurred). */
1505
1983
  protected abstract compareValuePropertyValues(old: any, val: any): boolean;
1984
+ /** @readonly Gets the human-readable representation of {@link value}, recomputed via {@link getViewValue} whenever `value` changes. */
1506
1985
  viewValue: string;
1986
+ /** Gets or sets the field's current value. Setting it (or the `value` attribute, converted via {@link convertValueAttributeToProperty}) also refreshes {@link viewValue}. */
1507
1987
  value: any;
1988
+ /** Gets or sets whether the field's value has changed since it was last pristine; reflected as the `pacem-dirty` CSS class. */
1508
1989
  dirty: boolean;
1990
+ /** Gets or sets whether the field currently passes validation; reflected as the `pacem-invalid` CSS class when `false`. */
1509
1991
  valid: boolean;
1992
+ /** Gets or sets the field name used to register/bind against the owning {@link PacemFormElement}. */
1510
1993
  name: string;
1511
1994
  }
1512
1995
 
1996
+ /** A `<p-namevalue-list>` field: a {@link PacemBaseElement} editor for a repeatable list of name/value string pairs, whose `value` is either an array of {@link NameValuePair}s or, when {@link PacemNameValueListElement#dictionary} is set, a plain `{ [name]: value }` object. */
1513
1997
  declare class PacemNameValueListElement extends PacemBaseElement {
1514
1998
  protected inputFields: HTMLElement[];
1515
1999
  protected toggleReadonlyView(readonly: boolean): void;
@@ -1521,6 +2005,7 @@ declare class PacemNameValueListElement extends PacemBaseElement {
1521
2005
  propertyChangedCallback(name: string, old: any, val: any, first?: boolean): void;
1522
2006
  /** Gets or sets whether the names should be unique */
1523
2007
  dictionary: boolean;
2008
+ /** Internal editable rows, mirrored to/from `value` depending on {@link dictionary}. */
1524
2009
  private _bag;
1525
2010
  private _bagToValue;
1526
2011
  private _valueToBag;
@@ -1528,9 +2013,11 @@ declare class PacemNameValueListElement extends PacemBaseElement {
1528
2013
  private _addItem;
1529
2014
  }
1530
2015
 
2016
+ /** {@link PacemOrdinalInputElement} for an `<input type="number">`, formatting its read-only view value via {@link format}. */
1531
2017
  declare class PacemNumberInputElement extends PacemOrdinalInputElement {
1532
2018
  private _input;
1533
2019
  private _span;
2020
+ /** Gets or sets the `Intl.NumberFormatOptions` used to render the read-only view value. */
1534
2021
  format: Intl.NumberFormatOptions;
1535
2022
  protected toggleReadonlyView(readonly: boolean): void;
1536
2023
  protected get inputFields(): HTMLInputElement[];
@@ -1541,14 +2028,23 @@ declare class PacemNumberInputElement extends PacemOrdinalInputElement {
1541
2028
  disconnectedCallback(): void;
1542
2029
  }
1543
2030
 
2031
+ /**
2032
+ * Base class for numeric/ordinal native inputs (e.g. `number`, `range`, `date`-like fields): adds
2033
+ * `min`/`max`/`step`, mirrored onto the native input's own attributes, and parses its `value` attribute as
2034
+ * a float.
2035
+ */
1544
2036
  declare abstract class PacemOrdinalInputElement extends PacemBaseInputElement {
2037
+ /** Gets or sets the minimum accepted value; mirrored onto the native input's `min` attribute. */
1545
2038
  min: any;
2039
+ /** Gets or sets the maximum accepted value; mirrored onto the native input's `max` attribute. */
1546
2040
  max: any;
2041
+ /** Gets or sets the step increment (a number, or `'any'`); mirrored onto the native input's `step` attribute. */
1547
2042
  step: any;
1548
2043
  protected convertValueAttributeToProperty(attr: string): number;
1549
2044
  propertyChangedCallback(name: string, old: any, val: any, first: boolean): void;
1550
2045
  }
1551
2046
 
2047
+ /** {@link PacemTextualInputElement} for an `<input type="password">`, with a toggle to reveal/hide the entered text and a masked read-only view. */
1552
2048
  declare class PacemPasswordInputElement extends PacemTextualInputElement {
1553
2049
  constructor();
1554
2050
  private _input;
@@ -1557,6 +2053,7 @@ declare class PacemPasswordInputElement extends PacemTextualInputElement {
1557
2053
  protected get inputFields(): HTMLInputElement[];
1558
2054
  viewActivatedCallback(): void;
1559
2055
  disconnectedCallback(): void;
2056
+ /** Toggles the native input between `password` (masked) and `text` (revealed) type. */
1560
2057
  toggleVisibility(): void;
1561
2058
  private _syncToggler;
1562
2059
  protected toggleReadonlyView(readonly: boolean): void;
@@ -1564,6 +2061,7 @@ declare class PacemPasswordInputElement extends PacemTextualInputElement {
1564
2061
  private _togglerMousedownHandler;
1565
2062
  }
1566
2063
 
2064
+ /** A `<p-property-picker>` field: a {@link PacemBaseElement} wrapping a {@link PacemSelectElement} whose datasource is auto-populated with the (recursively flattened) watched property names of a `target` element. */
1567
2065
  declare class PacemPropertyPickerElement extends PacemBaseElement {
1568
2066
  protected get inputFields(): HTMLElement[];
1569
2067
  protected toggleReadonlyView(readonly: boolean): void;
@@ -1572,12 +2070,14 @@ declare class PacemPropertyPickerElement extends PacemBaseElement {
1572
2070
  protected getViewValue(value: any): string;
1573
2071
  protected convertValueAttributeToProperty(attr: string): any;
1574
2072
  private _select;
2073
+ /** Gets or sets the element whose watched properties (including nested object properties, dot-separated) populate the picker's options. */
1575
2074
  target: HTMLElement;
1576
2075
  viewActivatedCallback(): void;
1577
2076
  propertyChangedCallback(name: string, old: any, val: any, first?: boolean): void;
1578
2077
  private _databind;
1579
2078
  }
1580
2079
 
2080
+ /** A `<p-radio>` field: a {@link PacemBaseElement} wrapping a single native `<input type="radio">` with a caption label; its `value` is the radio's native value when {@link selected}, otherwise `undefined`. Used standalone or as the item template driven by {@link PacemRadioListElement}. */
1581
2081
  declare class PacemRadioElement extends PacemBaseElement {
1582
2082
  protected convertValueAttributeToProperty(attr: string): string;
1583
2083
  constructor();
@@ -1585,7 +2085,9 @@ declare class PacemRadioElement extends PacemBaseElement {
1585
2085
  private _radio;
1586
2086
  private _label;
1587
2087
  span: HTMLElement;
2088
+ /** Gets or sets the label displayed next to the radio button. */
1588
2089
  caption: string;
2090
+ /** Gets or sets whether this radio button is checked. */
1589
2091
  selected: boolean;
1590
2092
  protected toggleReadonlyView(readonly: boolean): void;
1591
2093
  protected get inputFields(): HTMLInputElement[];
@@ -1596,6 +2098,7 @@ declare class PacemRadioElement extends PacemBaseElement {
1596
2098
  protected getViewValue(val: any): string;
1597
2099
  }
1598
2100
 
2101
+ /** A `<p-radio-list>` field: a {@link PacemDataSourceElement} rendering the datasource as a group of mutually-exclusive `<p-radio>` buttons. */
1599
2102
  declare class PacemRadioListElement extends PacemDataSourceElement {
1600
2103
  protected acceptValue(val: any): void;
1601
2104
  constructor();
@@ -1611,34 +2114,43 @@ declare class PacemRadioListElement extends PacemDataSourceElement {
1611
2114
  protected onChange(evt?: Event): Promise<any>;
1612
2115
  }
1613
2116
 
2117
+ /** Validates that a field's (non-empty) numeric or date value falls within `[min, max]` (`p-range-validator`); dates (parsed via `Utils.parseDate`) are compared by their timestamp. */
1614
2118
  declare class PacemRangeValidatorElement extends PacemBaseValidatorElement {
2119
+ /** Gets or sets the minimum accepted value (number or date-parsable), inclusive. */
1615
2120
  min: any;
2121
+ /** Gets or sets the maximum accepted value (number or date-parsable), inclusive. */
1616
2122
  max: any;
1617
2123
  propertyChangedCallback(name: string, old: any, val: any, first?: boolean): void;
1618
2124
  evaluate(val: any): Promise<boolean>;
1619
2125
  }
1620
2126
 
2127
+ /** Validates that a field's (non-empty) value matches a regular expression (`p-regex-validator`). */
1621
2128
  declare class PacemRegexValidatorElement extends PacemBaseValidatorElement {
2129
+ /** Gets or sets the regular expression (or its source string) the field's value must match. */
1622
2130
  pattern: string | RegExp;
1623
2131
  propertyChangedCallback(name: string, old: any, val: any, first?: boolean): void;
1624
2132
  evaluate(val: any): Promise<boolean>;
1625
2133
  }
1626
2134
 
2135
+ /** Validates that a field's value is not empty (`p-required-validator`). */
1627
2136
  declare class PacemRequiredValidatorElement extends PacemBaseValidatorElement {
1628
2137
  evaluate(val: any): Promise<boolean>;
1629
2138
  }
1630
2139
 
2140
+ /** A `<p-input-search>` field: a {@link PacemTextualInputElement} backed by a native `<input type="search">`. */
1631
2141
  declare class PacemSearchInputElement extends PacemTextualInputElement {
1632
2142
  constructor();
1633
- input: HTMLInputElement;
2143
+ private _input;
1634
2144
  protected get inputFields(): HTMLInputElement[];
1635
2145
  protected toggleReadonlyView(readonly: boolean): void;
1636
2146
  }
1637
2147
 
2148
+ /** A `<p-select>` field: a {@link PacemDataSourceElement} rendering the datasource as a native `<select>` dropdown. */
1638
2149
  declare class PacemSelectElement extends PacemDataSourceElement {
1639
2150
  private _select;
1640
2151
  private _repeater;
1641
2152
  private _span;
2153
+ /** Gets or sets whether an extra, empty/placeholder `<option>` is prepended to the rendered choices. Defaults to `true`. */
1642
2154
  emptyOption: boolean;
1643
2155
  protected toggleReadonlyView(readonly: boolean): void;
1644
2156
  protected get inputFields(): HTMLSelectElement[];
@@ -1652,6 +2164,7 @@ declare class PacemSelectElement extends PacemDataSourceElement {
1652
2164
  disconnectedCallback(): void;
1653
2165
  }
1654
2166
 
2167
+ /** A `<p-slider>` field: a {@link PacemBaseElement} numeric range control with a draggable thumb, keyboard support, and an optional tooltip-style thumb label; its `value` is a number between `min` and `max`. */
1655
2168
  declare class PacemSliderElement extends PacemBaseElement {
1656
2169
  protected inputFields: HTMLElement[];
1657
2170
  protected onChange(evt?: Event): PromiseLike<any>;
@@ -1660,11 +2173,17 @@ declare class PacemSliderElement extends PacemBaseElement {
1660
2173
  protected acceptValue(val: any): void;
1661
2174
  protected getViewValue(value: any): string;
1662
2175
  protected convertValueAttributeToProperty(attr: string): number;
2176
+ /** Gets or sets the minimum accepted value. */
1663
2177
  min: number;
2178
+ /** Gets or sets the maximum accepted value. */
1664
2179
  max: number;
2180
+ /** Gets or sets whether a tooltip-style label showing the current value is displayed over the thumb (on hover/focus). */
1665
2181
  thumbLabel: boolean;
2182
+ /** Gets or sets the step increment (a number, or `'any'`) the value snaps to while dragging/using the keyboard. */
1666
2183
  step: 'any' | number;
2184
+ /** Gets or sets when the value is committed while dragging the thumb: continuously (`'drag'`, default) or only once the drag ends (`'end'`). */
1667
2185
  changePolicy: 'drag' | 'end';
2186
+ /** Gets or sets the `Intl.NumberFormat` options used to format the displayed value; falls back to a plain `toLocaleString()`, or a `formatvalue` event listener's `output`, when unset. */
1668
2187
  format: Intl.NumberFormatOptions;
1669
2188
  private _track;
1670
2189
  private _progress;
@@ -1690,6 +2209,7 @@ declare class PacemSliderElement extends PacemBaseElement {
1690
2209
  propertyChangedCallback(name: string, old: any, val: any, first?: boolean): void;
1691
2210
  }
1692
2211
 
2212
+ /** A `<p-snapshot>` field: a {@link PacemBaseElement} image-capture control that lets the user upload a file or, when a webcam is available, take a live snapshot (with an optional 3s timer); its `value` is the resulting data-URL string. */
1693
2213
  declare class PacemSnapshotElement extends PacemBaseElement {
1694
2214
  protected get inputFields(): HTMLElement[];
1695
2215
  protected toggleReadonlyView(readonly: boolean): void;
@@ -1707,14 +2227,20 @@ declare class PacemSnapshotElement extends PacemBaseElement {
1707
2227
  private _taker;
1708
2228
  private _timer;
1709
2229
  private _confirmer;
2230
+ /** Gets or sets the current step of the capture workflow. Defaults to {@link SnapshotStep.Start}. */
1710
2231
  step: SnapshotStep;
2232
+ /** Gets or sets the width (in pixels) the captured/rendered image is cropped/rendered to. */
1711
2233
  width: number;
2234
+ /** Gets or sets the height (in pixels) the captured/rendered image is cropped/rendered to. */
1712
2235
  height: number;
2236
+ /** Gets or sets the JPEG/PNG encoding quality (0 to 1) used when exporting the captured image. */
1713
2237
  quality: number;
1714
2238
  get _getUserMedia(): any;
1715
2239
  private _canUseWebcam;
2240
+ /** Seconds left before the timed shutter fires; `0` outside of a timed countdown. */
1716
2241
  private _countdown;
1717
2242
  private _webcamInitialized;
2243
+ /** Internal data-URL of the just-captured (not yet confirmed) image, pending user confirmation. */
1718
2244
  private _buffer;
1719
2245
  propertyChangedCallback(name: string, old: any, val: any, first?: boolean): void;
1720
2246
  viewActivatedCallback(): void;
@@ -1733,6 +2259,7 @@ declare class PacemSnapshotElement extends PacemBaseElement {
1733
2259
  private _ensureWebcamRunning;
1734
2260
  }
1735
2261
 
2262
+ /** A `<p-suggest>` field: a {@link PacemDataSourceElement} autocomplete/typeahead text input, backed by a native `<input type="text">` and a dropdown balloon of filtered, highlighted suggestions; optionally accepts free-typed values not present in the datasource. */
1736
2263
  declare class PacemSuggestElement extends PacemDataSourceElement {
1737
2264
  #private;
1738
2265
  private _input;
@@ -1744,6 +2271,7 @@ declare class PacemSuggestElement extends PacemDataSourceElement {
1744
2271
  private _btnClear;
1745
2272
  private _balloon;
1746
2273
  protected get inputFields(): HTMLInputElement[];
2274
+ /** Gets or sets the current raw text typed/displayed in the native input, kept in sync with (but distinct from) the resolved `value`. */
1747
2275
  hint: string;
1748
2276
  /** Default: 10 (i.e. assumed `10` when not defined) */
1749
2277
  maxSuggestions: number;
@@ -1751,6 +2279,7 @@ declare class PacemSuggestElement extends PacemDataSourceElement {
1751
2279
  allowTyping: boolean;
1752
2280
  /** Relevant in a rich/plain text header dashboard, in order to avoid the editing control to lose focus. */
1753
2281
  preventFocus: boolean;
2282
+ /** Gets or sets a custom `<template>` used to render each suggestion list item, in place of the default plain-text/highlighted item. */
1754
2283
  itemtemplate: HTMLTemplateElement;
1755
2284
  /** Fields (in addition to 'textProperty') used to filter the datasource */
1756
2285
  filterFields: string[];
@@ -1791,19 +2320,27 @@ declare class PacemSuggestElement extends PacemDataSourceElement {
1791
2320
  private _createBalloon;
1792
2321
  }
1793
2322
 
2323
+ /** A single `<p-tag>` chip: displays a label and a remove button, dispatching a `remove` event (after an out-transition) when dismissed. Rendered by {@link PacemTagsElement} for each item in its `value`. */
1794
2324
  declare class PacemTagElement extends Components_2.PacemElement {
2325
+ /** Gets or sets the chip's display label. */
1795
2326
  tag: string;
2327
+ /** Gets or sets whether the chip's remove button is hidden/disabled. */
1796
2328
  readonly: boolean;
1797
2329
  private _btn;
1798
2330
  propertyChangedCallback(name: string, old: any, val: any, first?: boolean): void;
1799
2331
  private _remove;
1800
2332
  }
1801
2333
 
2334
+ /** A `<p-tags>` field: a {@link PacemDataSourceElement} editor rendering `value` as a list of removable {@link PacemTagElement} chips, plus a {@link PacemSuggestElement} for picking (or, when {@link allowNew} is set, typing) new tags to add. */
1802
2335
  declare class PacemTagsElement extends PacemDataSourceElement {
1803
2336
  constructor();
2337
+ /** Gets or sets the current raw text typed into the underlying {@link PacemSuggestElement} used to pick/type new tags. */
1804
2338
  hint: string;
2339
+ /** Gets or sets whether the same tag value can be added more than once. */
1805
2340
  allowDuplicates: boolean;
2341
+ /** Gets or sets whether values not present in the `datasource` can be typed and added as new tags. */
1806
2342
  allowNew: boolean;
2343
+ /** Index, within `value`, of the tag most recently added (drives its enter transition); `-1` when none. */
1807
2344
  private _justAddedIndex;
1808
2345
  private _suggest;
1809
2346
  private _tags;
@@ -1817,16 +2354,20 @@ declare class PacemTagsElement extends PacemDataSourceElement {
1817
2354
  protected acceptValue(val: any): void;
1818
2355
  }
1819
2356
 
2357
+ /** A `<p-input-tel>` field: a {@link PacemTextualInputElement} backed by a native `<input type="tel">`, whose readonly view renders as a clickable `tel:` link. */
1820
2358
  declare class PacemTelInputElement extends PacemTextualInputElement {
1821
2359
  constructor();
1822
- input: HTMLInputElement;
1823
- anchor: Components_3.UI.PacemAnchorElement;
2360
+ private _input;
2361
+ private _anchor;
1824
2362
  protected toggleReadonlyView(readonly: boolean): void;
1825
2363
  protected get inputFields(): HTMLInputElement[];
1826
2364
  }
1827
2365
 
2366
+ /** A `<p-textarea>` field: a {@link PacemTextualInputElement} backed by a native `<textarea>`, with an optional character counter. */
1828
2367
  declare class PacemTextAreaElement extends PacemTextualInputElement {
2368
+ /** Gets or sets the native `<textarea>`'s `rows` attribute. Defaults to `5`. */
1829
2369
  rows: number;
2370
+ /** Gets or sets the native `<textarea>`'s `cols` attribute. Defaults to `50`. */
1830
2371
  cols: number;
1831
2372
  private _input;
1832
2373
  private _span;
@@ -1837,6 +2378,7 @@ declare class PacemTextAreaElement extends PacemTextualInputElement {
1837
2378
  propertyChangedCallback(name: string, old: any, val: any, first: boolean): void;
1838
2379
  }
1839
2380
 
2381
+ /** A `<p-input-text>` field: a {@link PacemTextualInputElement} backed by a native `<input type="text">`, with an optional character counter. */
1840
2382
  declare class PacemTextInputElement extends PacemTextualInputElement {
1841
2383
  constructor();
1842
2384
  private _input;
@@ -1845,9 +2387,17 @@ declare class PacemTextInputElement extends PacemTextualInputElement {
1845
2387
  protected get inputFields(): HTMLInputElement[];
1846
2388
  }
1847
2389
 
2390
+ /**
2391
+ * Base class for text-like native inputs (e.g. `text`, `password`, `textarea` fields): adds
2392
+ * `pattern`/`minlength`/`maxlength`, mirrored onto the native input's own attributes, and treats an empty
2393
+ * string `value` as `null`.
2394
+ */
1848
2395
  declare abstract class PacemTextualInputElement extends PacemBaseInputElement {
2396
+ /** Gets or sets a regex pattern the native input's value must match; mirrored onto the native input's `pattern` attribute. */
1849
2397
  pattern: string;
2398
+ /** Gets or sets the minimum accepted text length; mirrored onto the native input's `minlength` attribute. */
1850
2399
  minlength: number;
2400
+ /** Gets or sets the maximum accepted text length; mirrored onto the native input's `maxlength` attribute. */
1851
2401
  maxlength: number;
1852
2402
  protected convertValueAttributeToProperty(attr: string): string;
1853
2403
  propertyChangedCallback(name: string, old: any, val: any, first: boolean): void;
@@ -1856,11 +2406,14 @@ declare abstract class PacemTextualInputElement extends PacemBaseInputElement {
1856
2406
  }
1857
2407
 
1858
2408
  /**
1859
- * PacemUploader Component
2409
+ * PacemUploader Component: {@link PacemBaseElement}-based field to pick and (optionally chunk-)upload file(s)/a directory to {@link url},
2410
+ * or defer to the File System Access API pickers depending on {@link selectMode}.
1860
2411
  */
1861
2412
  declare class PacemUploadElement extends PacemBaseElement implements Net.OAuthFetchable {
1862
2413
  private _tweener;
2414
+ /** Gets or sets the credentials mode used for the upload fetch requests. */
1863
2415
  fetchCredentials: RequestCredentials;
2416
+ /** Gets or sets the extra headers sent along with the upload fetch requests. */
1864
2417
  fetchHeaders: {
1865
2418
  [key: string]: string;
1866
2419
  };
@@ -1869,25 +2422,42 @@ declare class PacemUploadElement extends PacemBaseElement implements Net.OAuthFe
1869
2422
  protected acceptValue(val: any): void;
1870
2423
  private _fileupload;
1871
2424
  private _tuner;
2425
+ /** Gets or sets the caption of the "undo" button, shown while an upload with {@link url} set is in progress. */
1872
2426
  undoCaption: string;
2427
+ /** Gets or sets the caption of the "retry" button, shown after a {@link failed} upload. */
1873
2428
  retryCaption: string;
2429
+ /** Gets or sets the caption of the "clear" button. */
1874
2430
  clearCaption: string;
2431
+ /** Gets or sets a filename-matching regex pattern; files not matching it are flagged {@link invalidFile}. */
1875
2432
  pattern: string;
2433
+ /** Gets or sets the endpoint the file is chunk-uploaded to; when unset, the field simply resolves to the picked file/blob (a "mimic" upload is played instead). */
1876
2434
  url: string;
2435
+ /** Gets or sets the max width (in pixels) an image is resized to before upload. */
1877
2436
  maxImageWidth: number;
2437
+ /** Gets or sets how many chunks may be uploaded concurrently. */
1878
2438
  parallelism: number;
2439
+ /** Gets or sets the size (in bytes) of each uploaded chunk. */
1879
2440
  chunkSize: number;
2441
+ /** Gets or sets the max height (in pixels) an image is resized to before upload. */
1880
2442
  maxImageHeight: number;
1881
2443
  /** Gets or sets the max blob size in bytes. */
1882
2444
  maxSize: number;
2445
+ /** Gets or sets what kind of selection this uploader offers: a single file/directory (via `<input type=file>`) or via the File System Access API pickers. */
1883
2446
  selectMode: BinarySelectMode;
2447
+ /** @readonly Gets whether an upload is currently in progress. */
1884
2448
  uploading: boolean;
2449
+ /** @readonly Gets the total size (in bytes) of the file(s) currently being uploaded. */
1885
2450
  size: number;
2451
+ /** @readonly Gets the current upload progress, from 0 to 100. */
1886
2452
  percentage: number;
2453
+ /** @readonly Gets whether the current upload has completed. */
1887
2454
  complete: boolean;
2455
+ /** @readonly Gets whether the current upload chunk request failed (enabling the retry button). */
1888
2456
  failed: boolean;
2457
+ /** @readonly Gets whether the selected file failed {@link pattern}/{@link maxSize} validation. */
1889
2458
  invalidFile: boolean;
1890
2459
  private _getMimeIcon;
2460
+ /** @readonly Gets the raw blob currently being (or last) uploaded. */
1891
2461
  get blob(): Blob;
1892
2462
  protected get inputFields(): HTMLInputElement[];
1893
2463
  protected getViewValue(val: any): string;
@@ -1929,14 +2499,16 @@ declare class PacemUploadElement extends PacemBaseElement implements Net.OAuthFe
1929
2499
  private _clear;
1930
2500
  }
1931
2501
 
2502
+ /** A `<p-input-url>` field: a {@link PacemTextualInputElement} backed by a native `<input type="url">`, whose readonly view renders as a clickable link opening in a new tab. */
1932
2503
  declare class PacemUrlInputElement extends PacemTextualInputElement {
1933
2504
  constructor();
1934
- input: HTMLInputElement;
1935
- anchor: Components_3.UI.PacemAnchorElement;
2505
+ private _input;
2506
+ private _anchor;
1936
2507
  protected toggleReadonlyView(readonly: boolean): void;
1937
2508
  protected get inputFields(): HTMLInputElement[];
1938
2509
  }
1939
2510
 
2511
+ /** A single page of `T` items carved out of a larger, server-paged set. */
1940
2512
  declare type PagedSet<T> = {
1941
2513
  set: T[];
1942
2514
  skip: number;
@@ -1945,17 +2517,20 @@ declare type PagedSet<T> = {
1945
2517
  size: number;
1946
2518
  };
1947
2519
 
2520
+ /** A named, possibly required, piece of data (e.g. an API parameter). */
1948
2521
  declare type Parameter = {
1949
2522
  name: string;
1950
2523
  required: boolean;
1951
2524
  };
1952
2525
 
2526
+ /** A single image entry (full-size and thumbnail sources) offered as a pick candidate by {@link PacemEditImageElement}. */
1953
2527
  declare class Picture {
1954
2528
  thumbnailSrc: string;
1955
2529
  src: string;
1956
2530
  caption?: string;
1957
2531
  }
1958
2532
 
2533
+ /** A page of {@link Picture}s, as returned in response to an {@link ImageFetchRequestEvent}. */
1959
2534
  declare type PictureSet = {
1960
2535
  total: number;
1961
2536
  skip: number;
@@ -1963,6 +2538,7 @@ declare type PictureSet = {
1963
2538
  set: Picture[];
1964
2539
  };
1965
2540
 
2541
+ /** Describes a single entity property for auto-generated form scaffolding: its `type` (built-in kind, or a custom {@link PropertyMetadataFieldFactory}), display, validators, commands, dependency and nesting ({@link props}) information. Consumed by `PacemFormFieldElement` (not in this file) and referenced from {@link TypeMetadata}/{@link PacemFormElement#metadata}. */
1966
2542
  declare type PropertyMetadata = {
1967
2543
  prop: string;
1968
2544
  type: 'object' | 'array' | string | /* let the possibility to inject custom scaffolding elements */ PropertyMetadataFieldFactory;
@@ -1980,31 +2556,39 @@ declare type PropertyMetadata = {
1980
2556
  props?: TypeMetadata | PropertyMetadata[];
1981
2557
  };
1982
2558
 
1983
- /** @deprecated */
2559
+ /** @deprecated Alias kept for backwards compatibility: use {@link PropertyMetadataCore} (re-exported from `./types`) instead. */
1984
2560
  declare type PropertyMetadata_2 = PropertyMetadata;
1985
2561
 
2562
+ /** Factory invoked at scaffolding time to compute a {@link DependsOn}-driven {@link DependsOnManifest} for a generated field. */
1986
2563
  declare type PropertyMetadataDependsOnFactory = (host: Element, hostRef?: string, entityRef?: string, fieldEntityRef?: string) => DependsOnManifest;
1987
2564
 
2565
+ /** Factory invoked at scaffolding time to compute a {@link DisplayMetadata#cssClass} databinding expression for a generated field, given the `host` element and (optionally) the databinding references to the host and entity. */
1988
2566
  declare type PropertyMetadataDisplayCssClassFactory = (host: Element, hostRef?: string, entityRef?: string) => DisplayCssClassManifest;
1989
2567
 
2568
+ /** Factory invoked at scaffolding time to compute a {@link DisplayMetadata#css} databinding expression for a generated field, given the `host` element and (optionally) the databinding references to the host and entity. */
1990
2569
  declare type PropertyMetadataDisplayCssFactory = (host: Element, hostRef?: string, entityRef?: string) => DisplayCssManifest;
1991
2570
 
2571
+ /** Union of all the field-kind-specific extra options a {@link PropertyMetadata#extra} can carry, on top of the {@link PropertyMetadataExtraCore} ones common to every field. */
1992
2572
  declare type PropertyMetadataExtra = PropertyMetadataExtraCore & (PropertyMetadataExtraDatasource & PropertyMetadataExtraSnapshot & PropertyMetadataExtraTags & PropertyMetadataExtraChildform & PropertyMetadataExtraUpload & PropertyMetadataExtraSlider & PropertyMetadataExtraDatetime & PropertyMetadataExtraCode);
1993
2573
 
2574
+ /** {@link PropertyMetadataExtra} fields specific to child-form (nested entity/array) fields. */
1994
2575
  declare type PropertyMetadataExtraChildform = {
1995
2576
  lockItems?: boolean;
1996
2577
  };
1997
2578
 
2579
+ /** {@link PropertyMetadataExtra} fields specific to code-editor-like text fields. */
1998
2580
  declare type PropertyMetadataExtraCode = {
1999
2581
  charCount?: number;
2000
2582
  inputTransform?: 'none' | 'lowercase' | 'uppercase' | 'password';
2001
2583
  };
2002
2584
 
2585
+ /** {@link PropertyMetadataExtra} fields applicable regardless of the field's `type`/`ui`. */
2003
2586
  declare type PropertyMetadataExtraCore = {
2004
2587
  dependsOn?: DependsOn[] | PropertyMetadataDependsOnFactory;
2005
2588
  autofocus?: boolean;
2006
2589
  } & TooltipMetadata;
2007
2590
 
2591
+ /** {@link PropertyMetadataExtra} fields specific to datasource-driven fields (lists, selects, radio groups, autocomplete/suggest). */
2008
2592
  declare type PropertyMetadataExtraDatasource = {
2009
2593
  source?: Function | any[];
2010
2594
  sourceUrl?: string;
@@ -2020,28 +2604,33 @@ declare type PropertyMetadataExtraDatasource = {
2020
2604
  filterFields?: string[] | string;
2021
2605
  };
2022
2606
 
2607
+ /** {@link PropertyMetadataExtra} fields specific to date/time fields. */
2023
2608
  declare type PropertyMetadataExtraDatetime = {
2024
2609
  /** @deprecated use display format field instead. */
2025
2610
  format?: string | Intl.DateTimeFormatOptions;
2026
2611
  disabledRanges?: Components_3.UI.DateRange[];
2027
2612
  };
2028
2613
 
2614
+ /** {@link PropertyMetadataExtra} fields specific to slider/range fields. */
2029
2615
  declare type PropertyMetadataExtraSlider = {
2030
2616
  step?: 'any' | number;
2031
2617
  preventWheel?: boolean;
2032
2618
  };
2033
2619
 
2620
+ /** {@link PropertyMetadataExtra} fields specific to image/snapshot fields. */
2034
2621
  declare type PropertyMetadataExtraSnapshot = {
2035
2622
  width?: number;
2036
2623
  height?: number;
2037
2624
  quality?: number;
2038
2625
  };
2039
2626
 
2627
+ /** {@link PropertyMetadataExtra} fields specific to tag-list fields. */
2040
2628
  declare type PropertyMetadataExtraTags = {
2041
2629
  allowNew?: boolean;
2042
2630
  allowDuplicates?: boolean;
2043
2631
  };
2044
2632
 
2633
+ /** {@link PropertyMetadataExtra} fields specific to upload fields. */
2045
2634
  declare type PropertyMetadataExtraUpload = {
2046
2635
  maxImageWidth?: number;
2047
2636
  maxImageHeight?: number;
@@ -2051,12 +2640,16 @@ declare type PropertyMetadataExtraUpload = {
2051
2640
  mode?: BinarySelectMode;
2052
2641
  };
2053
2642
 
2643
+ /** Factory invoked at scaffolding time to build a custom field's markup (via {@link FieldManifest}) in place of the built-in `type`-driven rendering; used as {@link PropertyMetadata#type}. */
2054
2644
  declare type PropertyMetadataFieldFactory = (host: Element, hostRef?: string, entityRef?: string) => FieldManifest;
2055
2645
 
2646
+ /** Factory invoked at scaffolding time to compute a dynamic label (via {@link LabelManifest}) for a generated field, in place of a static {@link DisplayMetadata#name} string. */
2056
2647
  declare type PropertyMetadataLabelFactory = (host: Element, hostRef?: string, entityRef?: string, formRef?: string) => LabelManifest;
2057
2648
 
2649
+ /** Factory invoked at scaffolding time to compute the attributes of a custom validator element, given the `host` element and (optionally) the databinding references to the host and entity. */
2058
2650
  declare type PropertyMetadataValidatorFactory = (host: Element, hostRef?: string, entityRef?: string) => ValidatorManifest;
2059
2651
 
2652
+ /** Outcome of a check on whether a `Range` wraps an inert (`contenteditable=false`) element: `result` tells whether it does, `element` is that element, if any. */
2060
2653
  declare type RangeWrapTestResult = {
2061
2654
  result: boolean;
2062
2655
  element?: Node;
@@ -2210,20 +2803,29 @@ export declare namespace Scaffolding_2 {
2210
2803
  }
2211
2804
  }
2212
2805
 
2806
+ /** Schema metadata attached to a piece of data: the raw OpenAPI/Swagger schema, its resolved type name, and the form fields derived from it. */
2213
2807
  declare type Schema = {
2214
2808
  meta?: OpenApiSwagger.Schema;
2215
2809
  fullType?: string;
2216
2810
  fields?: DataField[];
2217
2811
  };
2218
2812
 
2813
+ /** The current stage of {@link PacemSnapshotElement}'s capture workflow: idle/upload-or-camera choice, live webcam preview, or reviewing the captured image before confirming. */
2219
2814
  declare enum SnapshotStep {
2220
2815
  Start = "start",
2221
2816
  Taking = "taking",
2222
2817
  Confirm = "confirm"
2223
2818
  }
2224
2819
 
2820
+ /** Parses a Swagger (OpenAPI 2.0) document into a format-agnostic {@link ApiManifest}, translating its `paths`/`definitions` into endpoints, resolved schema definitions and parameter types used to auto-generate form fields. */
2225
2821
  declare class SwaggerParser extends ApiParserBase {
2226
2822
  private _findDefinitionName;
2823
+ /**
2824
+ * Parses a Swagger (OpenAPI 2.0) document into an {@link ApiManifest}.
2825
+ * @param content The Swagger document, either as a parsed object or as a JSON string.
2826
+ * @param url Base url of the API, used to derive `baseUrl` when the document doesn't specify `host`/`schemes`.
2827
+ * @returns The parsed manifest, with endpoints and resolved schema definitions.
2828
+ */
2227
2829
  parse(content: any, url?: string): ApiManifest;
2228
2830
  private _tryGetEndpoint;
2229
2831
  private _translateType;
@@ -2231,6 +2833,7 @@ declare class SwaggerParser extends ApiParserBase {
2231
2833
  private _tryGetResponse;
2232
2834
  }
2233
2835
 
2836
+ /** Extended tooltip configuration: content mode plus the balloon's positioning/trigger/alignment. */
2234
2837
  declare type TooltipBalloonMetadata = {
2235
2838
  type: TooltipTypeMetadata;
2236
2839
  position?: Components_3.UI.BalloonPosition;
@@ -2238,27 +2841,35 @@ declare type TooltipBalloonMetadata = {
2238
2841
  align?: Components_3.UI.BalloonAlignment;
2239
2842
  };
2240
2843
 
2844
+ /** Adds an optional tooltip - either a simple {@link TooltipTypeMetadata} or a fully-configured {@link TooltipBalloonMetadata} - to a generated field. */
2241
2845
  declare type TooltipMetadata = {
2242
2846
  tooltip?: TooltipTypeMetadata | TooltipBalloonMetadata;
2243
2847
  };
2244
2848
 
2849
+ /** Which rich-content mode (if any) a tooltip's text is authored in, or a plain `boolean` to just toggle a default tooltip on/off. */
2245
2850
  declare type TooltipTypeMetadata = 'html' | 'md' | 'markdown' | 'text' | boolean;
2246
2851
 
2852
+ /** Describes an entity type for auto-generated form scaffolding: its display and the {@link PropertyMetadata} of each of its properties. Assignable to {@link PacemFormElement#metadata} to drive `autogenerate`. */
2247
2853
  declare type TypeMetadata = {
2248
2854
  display?: DisplayMetadata;
2249
2855
  props: PropertyMetadata[];
2250
2856
  type?: 'object' | 'array';
2251
2857
  };
2252
2858
 
2859
+ /** Minimal contract for anything that can validate a value and be registered against a {@link PacemFormElement} field: a `validate` function and the `invalid` outcome of the last run. */
2253
2860
  declare interface Validator {
2861
+ /** Whether the last {@link validate} call resolved to `false`. */
2254
2862
  invalid: boolean;
2863
+ /** Validates the given value, resolving `true` when valid. */
2255
2864
  validate: (val: any) => PromiseLike<boolean>;
2256
2865
  }
2257
2866
 
2867
+ /** Rendering-time output of a {@link PropertyMetadataValidatorFactory}: a map of attribute name to databinding expression, spread onto the generated validator element. */
2258
2868
  declare type ValidatorManifest = {
2259
2869
  [name: string]: string;
2260
2870
  };
2261
2871
 
2872
+ /** Metadata describing one validator to attach to a generated field: either a {@link KnownValidatorMetadata} kind, or a custom {@link ValidatorType} configured via fixed `params`/`errorMessage` or a dynamic {@link PropertyMetadataValidatorFactory}. */
2262
2873
  declare type ValidatorMetadata = KnownValidatorMetadata | {
2263
2874
  type: ValidatorType;
2264
2875
  errorMessage: string;
@@ -2268,6 +2879,7 @@ declare type ValidatorMetadata = KnownValidatorMetadata | {
2268
2879
  attributes: PropertyMetadataValidatorFactory;
2269
2880
  };
2270
2881
 
2882
+ /** A validator `type` not among the built-in {@link KnownValidatorMetadata} kinds - i.e. a custom validator element registered under that tag/type name. */
2271
2883
  declare type ValidatorType = Omit<string, 'required' | 'email' | 'length' | 'range' | 'regex' | 'binary' | 'compare' | 'async'>;
2272
2884
 
2273
2885