sg-widgets-core 0.3.0 → 0.4.0

package/dist/{client-CP9sWEVZ.d.mts → proxy-handler-C6XB6gss.d.mts}

@@ -38,70 +38,6 @@ declare function isLinkType(dataType: string): boolean;
 declare function isNumericType(dataType: string): boolean;
 declare function isTemporalType(dataType: string): boolean;
 //#endregion
-//#region src/filter.d.ts
-type LogicalOperator = 'and' | 'or';
-interface EntityRef {
-  type: string;
-  id: number;
-  /** `cached_display_name` of the target when known. Never sent to the API. */
-  name?: string;
-}
-type Scalar = string | number | boolean | null | EntityRef;
-type ConditionValue = Scalar | Scalar[] | [Scalar, Scalar] | [number, TimeUnit];
-interface FilterCondition {
-  kind: 'condition';
-  /** Dotted path such as `entity.Shot.code`. */
-  path: string;
-  operator: Operator;
-  value: ConditionValue;
-}
-interface FilterGroup {
-  kind: 'group';
-  logicalOperator: LogicalOperator;
-  conditions: FilterNode[];
-}
-type FilterNode = FilterGroup | FilterCondition;
-/** Wire shapes. */
-type WireCondition = [string, Operator, unknown];
-interface WireGroup {
-  logical_operator: LogicalOperator;
-  conditions: Array<WireCondition | WireGroup>;
-}
-/**
- * What one type's entry in `_text_search`'s `entity_types` map accepts: a filter
- * array, or a group this converts to one.
- */
-type TextSearchFilter = WireGroup | WireCondition[] | null | undefined;
-/**
- * The filter array `entity_types` wants, `[]` for no filter
- * (post_entity_text_search). The array form is `and` only and cannot express a
- * nested group, so one is refused here rather than sent and guessed at.
- */
-declare function toFilterArray(filter: TextSearchFilter): WireCondition[];
-declare function group(logicalOperator: LogicalOperator, conditions?: FilterNode[]): FilterGroup;
-declare function condition(path: string, operator: Operator, value: ConditionValue): FilterCondition;
-declare function emptyFilter(): FilterGroup;
-/**
- * A condition is blank when it has no path, or when its operator needs a value
- * and none was given. Blank conditions are dropped on serialisation rather than
- * sent as a degenerate filter.
- */
-declare function isBlankCondition(c: FilterCondition): boolean;
-/** True when serialisation would produce no conditions at all. */
-declare function isEmptyFilter(node: FilterNode): boolean;
-/**
- * Serialise a tree to the `api3_hash` `filters` value. Blank conditions and
- * groups that end up empty are dropped. Returns `null` when nothing remains,
- * so callers can omit `filters` rather than send `[]` (which matches every
- * row on the site).
- */
-declare function toApi3Hash(node: FilterNode): WireGroup | null;
-/** Parse a wire group (or a flat `api3_array` list) back into the editor tree. */
-declare function fromWire(wire: WireGroup | WireCondition[]): FilterGroup;
-/** Depth-first walk, useful for collecting referenced paths or validating against a schema. */
-declare function walk(node: FilterNode): Generator<FilterNode>;
-declare function referencedPaths(node: FilterNode): string[];
-//#endregion
 //#region src/schema.d.ts
 /** One property as the API returns it. */
 interface RawProperty<T = unknown> {
@@ -115,6 +51,10 @@ interface RawFieldSchema {
   editable: RawProperty<boolean>;
   mandatory: RawProperty<boolean>;
   unique: RawProperty<boolean>;
+  /** At the top level beside `name`, not under `properties` (116_field_settings_create_update). */
+  description?: RawProperty<string>;
+  /** At the top level too (002_schema). */
+  custom_metadata?: RawProperty<string>;
   /** `editable` here says whether the site may hide the field (056_stock_vs_custom_field). */
   visible?: RawProperty<boolean>;
   properties: Record<string, RawProperty<unknown>>;
@@ -369,6 +309,70 @@ type StatusGlyph = {
 /** The glyph a status draws, from its icon and whichever sprite can serve it. */
 declare function statusGlyph(status: Pick<StatusRecord, 'icon'> | null | undefined, siteUrl?: string): StatusGlyph;
 //#endregion
+//#region src/filter.d.ts
+type LogicalOperator = 'and' | 'or';
+interface EntityRef {
+  type: string;
+  id: number;
+  /** `cached_display_name` of the target when known. Never sent to the API. */
+  name?: string;
+}
+type Scalar = string | number | boolean | null | EntityRef;
+type ConditionValue = Scalar | Scalar[] | [Scalar, Scalar] | [number, TimeUnit];
+interface FilterCondition {
+  kind: 'condition';
+  /** Dotted path such as `entity.Shot.code`. */
+  path: string;
+  operator: Operator;
+  value: ConditionValue;
+}
+interface FilterGroup {
+  kind: 'group';
+  logicalOperator: LogicalOperator;
+  conditions: FilterNode[];
+}
+type FilterNode = FilterGroup | FilterCondition;
+/** Wire shapes. */
+type WireCondition = [string, Operator, unknown];
+interface WireGroup {
+  logical_operator: LogicalOperator;
+  conditions: Array<WireCondition | WireGroup>;
+}
+/**
+ * What one type's entry in `_text_search`'s `entity_types` map accepts: a filter
+ * array, or a group this converts to one.
+ */
+type TextSearchFilter = WireGroup | WireCondition[] | null | undefined;
+/**
+ * The filter array `entity_types` wants, `[]` for no filter
+ * (post_entity_text_search). The array form is `and` only and cannot express a
+ * nested group, so one is refused here rather than sent and guessed at.
+ */
+declare function toFilterArray(filter: TextSearchFilter): WireCondition[];
+declare function group(logicalOperator: LogicalOperator, conditions?: FilterNode[]): FilterGroup;
+declare function condition(path: string, operator: Operator, value: ConditionValue): FilterCondition;
+declare function emptyFilter(): FilterGroup;
+/**
+ * A condition is blank when it has no path, or when its operator needs a value
+ * and none was given. Blank conditions are dropped on serialisation rather than
+ * sent as a degenerate filter.
+ */
+declare function isBlankCondition(c: FilterCondition): boolean;
+/** True when serialisation would produce no conditions at all. */
+declare function isEmptyFilter(node: FilterNode): boolean;
+/**
+ * Serialise a tree to the `api3_hash` `filters` value. Blank conditions and
+ * groups that end up empty are dropped. Returns `null` when nothing remains,
+ * so callers can omit `filters` rather than send `[]` (which matches every
+ * row on the site).
+ */
+declare function toApi3Hash(node: FilterNode): WireGroup | null;
+/** Parse a wire group (or a flat `api3_array` list) back into the editor tree. */
+declare function fromWire(wire: WireGroup | WireCondition[]): FilterGroup;
+/** Depth-first walk, useful for collecting referenced paths or validating against a schema. */
+declare function walk(node: FilterNode): Generator<FilterNode>;
+declare function referencedPaths(node: FilterNode): string[];
+//#endregion
 //#region src/client.d.ts
 interface SearchOptions {
   filters?: WireGroup | null;
@@ -842,4 +846,246 @@ declare class RestClient implements SgClient {
 /** One `_search` row of `EventLogEntry`, with `meta` decoded as the API returns it. */
 declare function normalizeEventLogEntry(row: EntityRow): EventLogEntry;
 //#endregion
-export { NATIVE_STATUSES as $, ValueShape as $t, ThreadRow as A, Scalar as At, StatusIcon as B, referencedPaths as Bt, SummarizeResult as C, undeclaredField as Ct, SummaryType as D, FilterGroup as Dt, SummaryGrouping as E, FilterCondition as Et, hierarchyEntity as F, emptyFilter as Ft, intersectStatuses as G, DataType as Gt, StatusPaint as H, toFilterArray as Ht, normalizeEventLogEntry as I, fromWire as It, rgbToCss as J, OPERATORS_BY_TYPE as Jt, parseBgColor as K, NEGATING_OPERATORS as Kt, normalizeHierarchyNode as L, group as Lt, UploadResult as M, WireCondition as Mt, batchResults as N, WireGroup as Nt, TextSearchRow as O, FilterNode as Ot, eventLogFilters as P, condition as Pt, usableStatuses as Q, VALUE_SHAPE as Qt, Rgb as R, isBlankCondition as Rt, SummarizeOptions as S, statusFieldNameFor as St, SummaryGroup as T, EntityRef as Tt, StatusRecord as U, walk as Ut, StatusOption as V, toApi3Hash as Vt, foregroundFor as W, DATA_TYPES as Wt, statusLabel as X, TIME_UNITS as Xt, statusGlyph as Y, Operator as Yt, statusPaint as Z, TimeUnit as Zt, RestClientOptions as _, displayNameOf as _t, EntityTypeInfo as a, isTemporalType as an, SpriteCell as at, SgApiError as b, normalizeFields as bt, EventLogResult as c, nativeStatus as ct, HierarchyPath as d, DISPLAY_NAME_FIELDS as dt, isDataType as en, NativeStatus as et, HierarchyRef as f, FIELD_SCHEMA_OVERRIDES as ft, RestClient as g, RawProperty as gt, ReadOptions as h, RawFieldsResponse as ht, EntityRow as i, isOperator as in, STOCK_SPRITE_PATH as it, UploadFile as j, TextSearchFilter as jt, ThreadAuthor as k, LogicalOperator as kt, FollowingOptions as l, spriteStyle as lt, RawHierarchyNode as m, RawFieldSchema as mt, BatchResult as n, isLinkType as nn, STOCK_ICON_DATA_URLS as nt, EventLogEntry as o, operatorsFor as on, StockIconSource as ot, RawBatchRow as p, FieldSchema as pt, relativeLuminance as q, OPERATORS as qt, EVENT_LOG_FIELDS as r, isNumericType as rn, STOCK_ICON_KEYS as rt, EventLogOptions as s, supportsOperator as sn, isNativeStatus as st, BatchRequest as t, isFilterable as tn, STOCK_ICON_CELLS as tt, HierarchyNode as u, stockIconSource as ut, SearchOptions as v, fieldSchemaOverride as vt, SummaryField as w, ConditionValue as wt, SgClient as x, statusFieldFor as xt, SearchResult as y, normalizeField as yt, StatusGlyph as z, isEmptyFilter as zt };
+//#region src/proxy-client.d.ts
+interface ProxyClientOptions {
+  /** Where the endpoints live, e.g. `/sg` or `https://app.example.com/api/sg`. */
+  basePath: string;
+  fetch?: typeof fetch;
+  /** Extra request headers. Called per request, so a caller can rotate a CSRF or auth header. */
+  headers?: Record<string, string> | (() => Record<string, string> | Promise<Record<string, string>>);
+}
+declare class ProxyClient implements SgClient {
+  private readonly options;
+  private readonly base;
+  private readonly fetchFn;
+  constructor(options: ProxyClientOptions);
+  private post;
+  entityTypes(): Promise<EntityTypeInfo[]>;
+  fields(entityType: string, projectId?: number): Promise<Record<string, FieldSchema>>;
+  fieldWithProject(entityType: string, field: string, projectId: number): Promise<FieldSchema>;
+  search(entityType: string, options: SearchOptions): Promise<SearchResult>;
+  read(entityType: string, id: number, options?: ReadOptions): Promise<EntityRow>;
+  textSearch(text: string, entityTypes: Record<string, TextSearchFilter>, page?: {
+    size?: number;
+    number?: number;
+  }): Promise<TextSearchRow[]>;
+  statuses(): Promise<StatusRecord[]>;
+  create(entityType: string, body: Record<string, unknown>): Promise<EntityRow>;
+  delete(entityType: string, id: number): Promise<void>;
+  revive(entityType: string, id: number): Promise<boolean>;
+  batch(requests: BatchRequest[]): Promise<BatchResult[]>;
+  /** The bytes cross the protocol base64-encoded; the handler runs the three calls. */
+  upload(entityType: string, id: number, file: UploadFile): Promise<UploadResult>;
+  update(entityType: string, id: number, patch: Record<string, unknown>): Promise<EntityRow>;
+  hierarchySearch(rootPath: string, entity: EntityRef): Promise<HierarchyPath[]>;
+  hierarchyExpand(path: string): Promise<HierarchyNode>;
+  summarize(entityType: string, options?: SummarizeOptions): Promise<SummarizeResult>;
+  threadContents(noteId: number, entityFields?: Record<string, string[]>): Promise<ThreadRow[]>;
+  eventLog(options?: EventLogOptions): Promise<EventLogResult>;
+  following(userId: number, options?: FollowingOptions): Promise<EntityRef[]>;
+}
+//#endregion
+//#region src/schema-write.d.ts
+/** One setting of a field, in the shape a create and an update take. */
+interface SchemaProperty {
+  property_name: string;
+  value: unknown;
+}
+/** Settings as the API's list, or as a record turned into one in key order. */
+type SchemaProperties = SchemaProperty[] | Record<string, unknown>;
+declare function toSchemaProperties(properties?: SchemaProperties): SchemaProperty[];
+interface CreateFieldInput {
+  /**
+   * `text float number date date_time list url duration percent footage` take
+   * nothing else. `checkbox` needs `default_value` and `status_list` its
+   * `valid_values`; `entity` needs `valid_types`, one type or several, and
+   * `multi_entity` exactly one; `color`, `image` and `calculated` are refused
+   * (019_create_fields, 116_field_settings_create_update).
+   */
+  dataType: string;
+  /** Sent as the `name` property. The server derives the programmatic name from it. */
+  displayName: string;
+  /** Every other setting. A `name` here is sent after `displayName`. */
+  properties?: SchemaProperties;
+}
+interface CreatedField {
+  /** The programmatic name the server assigned: the last segment of `links.self`. It is not in the body. */
+  name: string;
+  /** `links.self` as it came. */
+  self: string;
+  /** The response's `data`, verbatim. */
+  raw: Record<string, unknown> | null;
+}
+/**
+ * What a read of one field answered. `raw` is the wrapped record verbatim, each
+ * value beside its `editable` flag, fit to store as a snapshot.
+ */
+type FieldReadResult = {
+  status: 'found';
+  field: FieldSchema;
+  raw: RawFieldSchema;
+} |
+/** 404 `Field '<Type>.<field>' does not exist.` A retired field and a name never used read the same (040_field_revive). */
+{
+  status: 'missing';
+  message: string;
+} |
+/** 200 with `data: null`: the row answers the field and the schema leaves it out (068_note_read_state). */
+{
+  status: 'undeclared';
+};
+/** `revived: false` carries the refusal as the server sent it. */
+type ReviveFieldResult = {
+  revived: true;
+} | {
+  revived: false;
+  status: number;
+  message: string;
+};
+interface SchemaClient {
+  /**
+   * One field of a type, at site scope or at a project's. Only `hidden_values`
+   * is measured to differ by project (009_status_lists).
+   *
+   * A field that does not exist is the `missing` result, not a rejection. Every
+   * other failure rejects, a type the site does not have included.
+   */
+  readField(entityType: string, field: string, projectId?: number): Promise<FieldReadResult>;
+  /** Every field of a type as the wrapped records, verbatim. About 48KB a type (get_schema_type_fields). */
+  readRawFields(entityType: string, projectId?: number): Promise<Record<string, RawFieldSchema>>;
+  /**
+   * Create a field and answer the name the server gave it.
+   *
+   * A display name already in use is a 201 for a suffixed field, `<name>_1`, with
+   * no warning, and a display name that starts `sg_` is prefixed again: compare
+   * the answered name with the wanted one, and read the type's fields before
+   * creating (019_create_fields, reports/006). A name a retired field holds is
+   * refused at 400; `reviveField` is the way back (040_field_revive).
+   */
+  createField(entityType: string, input: CreateFieldInput): Promise<CreatedField>;
+  /**
+   * Change a field's settings, at site scope or at a project's, and answer the
+   * record the server sent back.
+   *
+   * The answer is not proof: a `data_type` sent beside `properties` is a 200 that
+   * changes nothing. Read the field back (put_schema_type_fields_field). A
+   * property the update does not take is a 400 that lists the ones it does;
+   * `hidden_values` is not one (114_schema_admin_recheck).
+   */
+  updateField(entityType: string, field: string, properties: SchemaProperties, projectId?: number): Promise<RawFieldSchema | null>;
+  /**
+   * Retire a field. Its programmatic name is spent: the same name does not create
+   * again, only revive, and no call frees it (delete_schema_type_fields_field). A
+   * field already retired rejects with a 404 (114_schema_admin_recheck).
+   */
+  retireField(entityType: string, field: string): Promise<void>;
+  /**
+   * Bring a retired field back. It returns at the data type it was created at,
+   * so read it back (040_field_revive).
+   *
+   * A 204 is `revived: true`. A 4xx other than 401 and 403 is `revived: false`
+   * with the server's status and message; those two and everything else reject.
+   * The answer for a name with nothing retired behind it is not measured.
+   */
+  reviveField(entityType: string, field: string): Promise<ReviveFieldResult>;
+}
+/**
+ * A refusal from a schema call, as the server sent it: `status` and `body` whole,
+ * and the first error's `code`, `title`, `detail` and `source` lifted out.
+ *
+ * `message` is the `detail` where there is one and the `title` otherwise, followed
+ * by whatever only the `source` says. A 404 is titled `Not Found` and says which
+ * name is wrong in its `detail` (002_schema).
+ */
+declare class SchemaApiError extends SgApiError {
+  readonly code: number | null;
+  readonly title: string | null;
+  readonly detail: string | null;
+  readonly source: unknown;
+  constructor(status: number, body: unknown, message?: string);
+}
+/**
+ * A wrapped record as a `FieldSchema`. The record is left as it came; a key the
+ * response leaves out is read as its default, with the type taken from the path.
+ */
+declare function fieldFromRaw(entityType: string, name: string, raw: RawFieldSchema): FieldSchema;
+declare class RestSchemaClient implements SchemaClient {
+  private readonly options;
+  private readonly base;
+  private readonly fetchFn;
+  constructor(options: RestClientOptions);
+  private request;
+  readField(entityType: string, field: string, projectId?: number): Promise<FieldReadResult>;
+  readRawFields(entityType: string, projectId?: number): Promise<Record<string, RawFieldSchema>>;
+  createField(entityType: string, input: CreateFieldInput): Promise<CreatedField>;
+  updateField(entityType: string, field: string, properties: SchemaProperties, projectId?: number): Promise<RawFieldSchema | null>;
+  retireField(entityType: string, field: string): Promise<void>;
+  reviveField(entityType: string, field: string): Promise<ReviveFieldResult>;
+}
+/** The schema methods the proxy protocol carries, one POST each, beside `PROXY_METHODS`. */
+declare const SCHEMA_PROXY_METHODS: readonly ['readField', 'readRawFields', 'createField', 'updateField', 'retireField', 'reviveField'];
+type SchemaProxyMethod = (typeof SCHEMA_PROXY_METHODS)[number];
+declare function isSchemaProxyMethod(value: string): value is SchemaProxyMethod;
+/**
+ * The server half of `ProxySchemaClient`, in the protocol of `createProxyHandler`.
+ * It answers 404 to a method that is not a schema one, so a host routes on
+ * `isSchemaProxyMethod`, or hands the schema client to `createProxyHandler`.
+ *
+ * These calls change the site's schema for everyone: expose them only to the
+ * people who may.
+ */
+declare function createSchemaProxyHandler(client: SchemaClient): ProxyHandler;
+/** A `SchemaClient` over the host app's own endpoints: one POST per method under `basePath`. */
+declare class ProxySchemaClient implements SchemaClient {
+  private readonly options;
+  private readonly base;
+  private readonly fetchFn;
+  constructor(options: ProxyClientOptions);
+  private post;
+  readField(entityType: string, field: string, projectId?: number): Promise<FieldReadResult>;
+  readRawFields(entityType: string, projectId?: number): Promise<Record<string, RawFieldSchema>>;
+  createField(entityType: string, input: CreateFieldInput): Promise<CreatedField>;
+  updateField(entityType: string, field: string, properties: SchemaProperties, projectId?: number): Promise<RawFieldSchema | null>;
+  retireField(entityType: string, field: string): Promise<void>;
+  reviveField(entityType: string, field: string): Promise<ReviveFieldResult>;
+}
+//#endregion
+//#region src/proxy-handler.d.ts
+/** The methods the protocol carries, one POST each. */
+declare const PROXY_METHODS: readonly ['entityTypes', 'fields', 'fieldWithProject', 'search', 'read', 'textSearch', 'statuses', 'create', 'update', 'upload', 'hierarchyExpand', 'hierarchySearch', 'summarize', 'threadContents', 'eventLog', 'following', 'delete', 'revive', 'batch'];
+type ProxyMethod = (typeof PROXY_METHODS)[number];
+/** An error as it crosses the wire. `ProxyClient` rebuilds an `SgApiError` from it. */
+interface ProxyError {
+  status: number;
+  message: string;
+  body: unknown;
+}
+type ProxyBody = {
+  data: unknown;
+} | {
+  error: ProxyError;
+};
+interface ProxyResult {
+  /** HTTP status the wrapper writes. */
+  status: number;
+  body: ProxyBody;
+}
+type ProxyHandler = (method: string, body: unknown) => Promise<ProxyResult>;
+declare function isProxyMethod(value: string): value is ProxyMethod;
+/**
+ * Bytes as base64. The protocol is one JSON object per call, so an upload's bytes
+ * cross it encoded and are decoded here.
+ */
+declare function bytesToBase64(bytes: Uint8Array): string;
+declare function base64ToBytes(value: string): Uint8Array;
+interface ProxyHandlerOptions {
+  /**
+   * Also carry `SCHEMA_PROXY_METHODS` to this client. Left out, they are a 404:
+   * a schema write changes the site for everyone, so a host opts in.
+   */
+  schema?: SchemaClient;
+}
+/** Wraps a client so a host app can expose it over its own HTTP endpoints. */
+declare function createProxyHandler(client: SgClient, options?: ProxyHandlerOptions): ProxyHandler;
+//#endregion
+export { SummaryField as $, STOCK_SPRITE_PATH as $t, BatchRequest as A, isFilterable as An, toApi3Hash as At, HierarchyPath as B, intersectStatuses as Bt, SchemaProxyMethod as C, OPERATORS_BY_TYPE as Cn, condition as Ct, toSchemaProperties as D, VALUE_SHAPE as Dn, isBlankCondition as Dt, isSchemaProxyMethod as E, TimeUnit as En, group as Et, EventLogEntry as F, operatorsFor as Fn, StatusIcon as Ft, RestClient as G, statusLabel as Gt, RawBatchRow as H, relativeLuminance as Ht, EventLogOptions as I, supportsOperator as In, StatusOption as It, SearchResult as J, NATIVE_STATUSES as Jt, RestClientOptions as K, statusPaint as Kt, EventLogResult as L, StatusPaint as Lt, EVENT_LOG_FIELDS as M, isNumericType as Mn, walk as Mt, EntityRow as N, isOperator as Nn, Rgb as Nt, ProxyClient as O, ValueShape as On, isEmptyFilter as Ot, EntityTypeInfo as P, isTemporalType as Pn, StatusGlyph as Pt, SummarizeResult as Q, STOCK_ICON_KEYS as Qt, FollowingOptions as R, StatusRecord as Rt, SchemaProperty as S, OPERATORS as Sn, WireGroup as St, fieldFromRaw as T, TIME_UNITS as Tn, fromWire as Tt, RawHierarchyNode as U, rgbToCss as Ut, HierarchyRef as V, parseBgColor as Vt, ReadOptions as W, statusGlyph as Wt, SgClient as X, STOCK_ICON_CELLS as Xt, SgApiError as Y, NativeStatus as Yt, SummarizeOptions as Z, STOCK_ICON_DATA_URLS as Zt, ReviveFieldResult as _, statusFieldNameFor as _n, FilterNode as _t, ProxyHandlerOptions as a, stockIconSource as an, ThreadRow as at, SchemaClient as b, DataType as bn, TextSearchFilter as bt, base64ToBytes as c, FieldSchema as cn, batchResults as ct, isProxyMethod as d, RawProperty as dn, normalizeEventLogEntry as dt, SpriteCell as en, SummaryGroup as et, CreateFieldInput as f, displayNameOf as fn, normalizeHierarchyNode as ft, RestSchemaClient as g, statusFieldFor as gn, FilterGroup as gt, ProxySchemaClient as h, normalizeFields as hn, FilterCondition as ht, ProxyHandler as i, spriteStyle as in, ThreadAuthor as it, BatchResult as j, isLinkType as jn, toFilterArray as jt, ProxyClientOptions as k, isDataType as kn, referencedPaths as kt, bytesToBase64 as l, RawFieldSchema as ln, eventLogFilters as lt, FieldReadResult as m, normalizeField as mn, EntityRef as mt, ProxyBody as n, isNativeStatus as nn, SummaryType as nt, ProxyMethod as o, DISPLAY_NAME_FIELDS as on, UploadFile as ot, CreatedField as p, fieldSchemaOverride as pn, ConditionValue as pt, SearchOptions as q, usableStatuses as qt, ProxyError as r, nativeStatus as rn, TextSearchRow as rt, ProxyResult as s, FIELD_SCHEMA_OVERRIDES as sn, UploadResult as st, PROXY_METHODS as t, StockIconSource as tn, SummaryGrouping as tt, createProxyHandler as u, RawFieldsResponse as un, hierarchyEntity as ut, SCHEMA_PROXY_METHODS as v, undeclaredField as vn, LogicalOperator as vt, createSchemaProxyHandler as w, Operator as wn, emptyFilter as wt, SchemaProperties as x, NEGATING_OPERATORS as xn, WireCondition as xt, SchemaApiError as y, DATA_TYPES as yn, Scalar as yt, HierarchyNode as z, foregroundFor as zt };