node-autotask 0.60.0 → 0.61.0
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.
- package/CHANGELOG.md +27 -0
- package/MCP_TOOL_CATALOG.json +298 -9
- package/README.md +1 -1
- package/capabilities.json +1035 -7
- package/dist/capabilities-data.js +1034 -6
- package/dist/capabilities.cjs +4 -4
- package/dist/capabilities.js +1 -1
- package/dist/{chunk-MYLSBOZI.cjs → chunk-4SEIDMF6.cjs} +195 -11
- package/dist/{chunk-Y2SR6D2D.js → chunk-BSFJ5JYP.js} +190 -6
- package/dist/{chunk-VN3OZHC7.cjs → chunk-CWH2SLP2.cjs} +174 -174
- package/dist/{chunk-K722F7EM.js → chunk-GUXVYGBK.js} +3 -3
- package/dist/{chunk-XYWSPKCN.cjs → chunk-JTRC7XEH.cjs} +33 -31
- package/dist/{chunk-2GPQ55O6.js → chunk-NFTWRHUR.js} +4 -2
- package/dist/{chunk-XUPVX5MQ.js → chunk-O63FO5XC.js} +2 -2
- package/dist/{chunk-XP43NERF.cjs → chunk-TE7RUKU2.cjs} +3 -3
- package/dist/{index-cAntv7_A.d.ts → index-Bc3yX2Nc.d.ts} +4 -2
- package/dist/{index-D6bAO4ZV.d.cts → index-COQEG55Q.d.cts} +90 -1
- package/dist/{index-D6bAO4ZV.d.ts → index-COQEG55Q.d.ts} +90 -1
- package/dist/{index-BmaFIj42.d.cts → index-D1dW10iM.d.cts} +4 -2
- package/dist/index.cjs +84 -84
- package/dist/index.d.cts +3 -3
- package/dist/index.d.ts +3 -3
- package/dist/index.js +5 -5
- package/dist/operations/index.cjs +50 -50
- package/dist/operations/index.d.cts +4 -4
- package/dist/operations/index.d.ts +4 -4
- package/dist/operations/index.js +2 -2
- package/dist/pool.cjs +8 -8
- package/dist/pool.d.cts +1 -1
- package/dist/pool.d.ts +1 -1
- package/dist/pool.js +4 -4
- package/dist/resources/index.cjs +27 -27
- package/dist/resources/index.d.cts +2 -2
- package/dist/resources/index.d.ts +2 -2
- package/dist/resources/index.js +3 -3
- package/dist/types/index.d.cts +1 -1
- package/dist/types/index.d.ts +1 -1
- package/docs/API.md +4 -2
- package/package.json +5 -5
package/capabilities.json
CHANGED
|
@@ -1,9 +1,9 @@
|
|
|
1
1
|
{
|
|
2
|
-
"generatedAt": "2026-11-
|
|
2
|
+
"generatedAt": "2026-11-11T11:15:40.029Z",
|
|
3
3
|
"groups": {
|
|
4
4
|
"B": {
|
|
5
|
-
"planHash": "
|
|
6
|
-
"builtAt": "2026-11-
|
|
5
|
+
"planHash": "6ea020dd5a389c0930923a23c1074b96e4280391b1d4fe6fca869e0effbf3a1a",
|
|
6
|
+
"builtAt": "2026-11-11T11:15:40.015Z",
|
|
7
7
|
"records": [
|
|
8
8
|
{
|
|
9
9
|
"id": "appointments.count",
|
|
@@ -41559,6 +41559,1028 @@
|
|
|
41559
41559
|
"compact": "TimeOffRequestSummary",
|
|
41560
41560
|
"status": "tested"
|
|
41561
41561
|
},
|
|
41562
|
+
{
|
|
41563
|
+
"id": "user_defined_field_definitions.count",
|
|
41564
|
+
"resource": "user_defined_field_definitions",
|
|
41565
|
+
"udfCapable": false,
|
|
41566
|
+
"operation": "count",
|
|
41567
|
+
"kind": "primitive",
|
|
41568
|
+
"endpoint": "GET|POST /V1.0/UserDefinedFieldDefinitions/query/count",
|
|
41569
|
+
"effect": "read",
|
|
41570
|
+
"flags": [],
|
|
41571
|
+
"dryRun": false,
|
|
41572
|
+
"envelope": "QueryCountResultModel",
|
|
41573
|
+
"inputSchema": {
|
|
41574
|
+
"params": {
|
|
41575
|
+
"type": "object",
|
|
41576
|
+
"required": false,
|
|
41577
|
+
"description": "The query params object (CLOSED — unknown keys are refused pre-request): { filter?: FilterCondition[], fieldCheck?: boolean } — filter is the only wire parameter (the count endpoint takes no MaxRecords/IncludeFields; fieldCheck is consumed by the invoke router — never sent to the vendor). Filter condition field names are name-checked pre-request the same way as the query bag: a refusal costs zero /query/count wire (the cold fieldCache may cost the one authority metadata GET first). fieldCheck: false disables the name check (a non-boolean is refused pre-request; the shape/grammar checks always run) — the opt-out works on the count verb too.",
|
|
41578
|
+
"properties": [
|
|
41579
|
+
{
|
|
41580
|
+
"name": "filter",
|
|
41581
|
+
"type": "FilterCondition[]",
|
|
41582
|
+
"optional": true
|
|
41583
|
+
},
|
|
41584
|
+
{
|
|
41585
|
+
"name": "fieldCheck",
|
|
41586
|
+
"type": "boolean",
|
|
41587
|
+
"optional": true
|
|
41588
|
+
}
|
|
41589
|
+
]
|
|
41590
|
+
}
|
|
41591
|
+
},
|
|
41592
|
+
"inputSchemaStrict": true,
|
|
41593
|
+
"outputSchema": {
|
|
41594
|
+
"type": "QueryCountResultModel",
|
|
41595
|
+
"drops": []
|
|
41596
|
+
},
|
|
41597
|
+
"examples": [
|
|
41598
|
+
"await client.userDefinedFieldDefinitions.count({ filter: [{ field: 'name', op: 'eq', value: 'example' }] })"
|
|
41599
|
+
],
|
|
41600
|
+
"permissions": "unknown",
|
|
41601
|
+
"pagination": {
|
|
41602
|
+
"mode": "none"
|
|
41603
|
+
},
|
|
41604
|
+
"resolution": null,
|
|
41605
|
+
"retry": {
|
|
41606
|
+
"preset": "retry-ffb3a9cb"
|
|
41607
|
+
},
|
|
41608
|
+
"errors": {
|
|
41609
|
+
"set": 0
|
|
41610
|
+
},
|
|
41611
|
+
"metadata": {
|
|
41612
|
+
"purpose": "Count user-defined field definition records matching a JSON filter.",
|
|
41613
|
+
"usage": "Unwraps queryCount; returns a plain number.",
|
|
41614
|
+
"preferredWhen": null,
|
|
41615
|
+
"related": [
|
|
41616
|
+
"user_defined_field_definitions.query"
|
|
41617
|
+
],
|
|
41618
|
+
"args": "args[0] is a params object (CLOSED — unknown keys are refused pre-request): { filter?: FilterCondition[], fieldCheck?: boolean } — filter is the only parameter sent to the vendor (the count endpoint takes no MaxRecords/IncludeFields; fieldCheck is consumed by the invoke router — never sent to the vendor). Filter condition field names are name-checked pre-request the same way as the query bag: a refusal costs zero /query/count wire (the cold fieldCache may cost the one authority metadata GET first). fieldCheck: false disables the name check (a non-boolean is refused pre-request; the shape/grammar checks always run) — the opt-out works on the count verb too. Filter grammar: 13 operators: eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn (in/notIn: array or '1,2,3') + and/or grouping (no not-group). Field names in vendor API casing — get them via operations.fieldCatalog. Caps: 500 OR-conditions / 1 UDF / 8000 chars.",
|
|
41619
|
+
"untrustedFields": [
|
|
41620
|
+
"description",
|
|
41621
|
+
"mergeVariableName",
|
|
41622
|
+
"name"
|
|
41623
|
+
]
|
|
41624
|
+
},
|
|
41625
|
+
"compact": null,
|
|
41626
|
+
"status": "tested"
|
|
41627
|
+
},
|
|
41628
|
+
{
|
|
41629
|
+
"id": "user_defined_field_definitions.create",
|
|
41630
|
+
"resource": "user_defined_field_definitions",
|
|
41631
|
+
"udfCapable": false,
|
|
41632
|
+
"operation": "create",
|
|
41633
|
+
"kind": "primitive",
|
|
41634
|
+
"endpoint": "POST /V1.0/UserDefinedFieldDefinitions",
|
|
41635
|
+
"effect": "write",
|
|
41636
|
+
"flags": [],
|
|
41637
|
+
"dryRun": true,
|
|
41638
|
+
"envelope": "OperationResultModel",
|
|
41639
|
+
"inputSchema": {
|
|
41640
|
+
"data": {
|
|
41641
|
+
"type": "object",
|
|
41642
|
+
"required": true,
|
|
41643
|
+
"description": "The record payload (vendor model fields)."
|
|
41644
|
+
}
|
|
41645
|
+
},
|
|
41646
|
+
"inputSchemaStrict": true,
|
|
41647
|
+
"outputSchema": {
|
|
41648
|
+
"type": "OperationResultModel",
|
|
41649
|
+
"drops": []
|
|
41650
|
+
},
|
|
41651
|
+
"examples": [
|
|
41652
|
+
"await client.userDefinedFieldDefinitions.create({ name: 'example' }, { dryRun: true })"
|
|
41653
|
+
],
|
|
41654
|
+
"permissions": "unknown",
|
|
41655
|
+
"pagination": {
|
|
41656
|
+
"mode": "none"
|
|
41657
|
+
},
|
|
41658
|
+
"resolution": null,
|
|
41659
|
+
"retry": {
|
|
41660
|
+
"preset": "retry-c5657094"
|
|
41661
|
+
},
|
|
41662
|
+
"errors": {
|
|
41663
|
+
"set": 1
|
|
41664
|
+
},
|
|
41665
|
+
"metadata": {
|
|
41666
|
+
"purpose": "Create a UDF definition.",
|
|
41667
|
+
"usage": "Returns OperationResultModel.itemId (the new id); the full record is not returned — follow up with get where needed. Vendor constraints: `dataType` and `udfType` are chosen at creation and immutable after it (udfType 1 = Company/Account); for `dataType = List` the `defaultValue` cannot be set at creation (the list items must exist first); the vendor caps active company UDFs at 200.",
|
|
41668
|
+
"preferredWhen": "Only for a record that does not exist yet; prefer update for an id you already have.",
|
|
41669
|
+
"related": [
|
|
41670
|
+
"user_defined_field_definitions.update"
|
|
41671
|
+
],
|
|
41672
|
+
"deleteBoundary": {
|
|
41673
|
+
"resource": "user_defined_field_definitions",
|
|
41674
|
+
"note": "the vendor defines no DELETE for user_defined_field_definitions (spec-derived: the vendored api-docs.json defines no DELETE on the entity's paths) — a UDF definition cannot be deleted through the API; deactivation is via isActive (vendor soft-removal); hard cleanup is UI-only.",
|
|
41675
|
+
"proof": "spec-derived"
|
|
41676
|
+
},
|
|
41677
|
+
"untrustedFields": [
|
|
41678
|
+
"description",
|
|
41679
|
+
"mergeVariableName",
|
|
41680
|
+
"name"
|
|
41681
|
+
],
|
|
41682
|
+
"accountWide": true
|
|
41683
|
+
},
|
|
41684
|
+
"compact": null,
|
|
41685
|
+
"status": "tested"
|
|
41686
|
+
},
|
|
41687
|
+
{
|
|
41688
|
+
"id": "user_defined_field_definitions.get",
|
|
41689
|
+
"resource": "user_defined_field_definitions",
|
|
41690
|
+
"udfCapable": false,
|
|
41691
|
+
"operation": "get",
|
|
41692
|
+
"kind": "primitive",
|
|
41693
|
+
"endpoint": "GET /V1.0/UserDefinedFieldDefinitions/{id}",
|
|
41694
|
+
"effect": "read",
|
|
41695
|
+
"flags": [],
|
|
41696
|
+
"dryRun": false,
|
|
41697
|
+
"envelope": "ItemQueryResultModel[UserDefinedFieldDefinitionModel,UserDefinedFieldDefinition]",
|
|
41698
|
+
"inputSchema": {
|
|
41699
|
+
"id": {
|
|
41700
|
+
"type": "string | number",
|
|
41701
|
+
"required": true,
|
|
41702
|
+
"description": "The record id (number, or a canonical integer string — ids beyond 2^53 are supported via the string form)."
|
|
41703
|
+
},
|
|
41704
|
+
"opts": {
|
|
41705
|
+
"type": "object",
|
|
41706
|
+
"required": false,
|
|
41707
|
+
"description": "The read options bag (CLOSED): { fresh?: boolean } — fresh: true bypasses the read-cache lookup and refreshes the entry with the live response. Omitted: the cached read (default unchanged). A positional fresh via invoke is REFUSED (typed error, zero wire — the fresh invoke option is the only spelling); the typed method get(id, { fresh: true }) is unchanged.",
|
|
41708
|
+
"properties": [
|
|
41709
|
+
{
|
|
41710
|
+
"name": "fresh",
|
|
41711
|
+
"type": "boolean",
|
|
41712
|
+
"optional": true
|
|
41713
|
+
}
|
|
41714
|
+
]
|
|
41715
|
+
}
|
|
41716
|
+
},
|
|
41717
|
+
"inputSchemaStrict": true,
|
|
41718
|
+
"outputSchema": {
|
|
41719
|
+
"type": "ItemQueryResultModel[UserDefinedFieldDefinitionModel,UserDefinedFieldDefinition]",
|
|
41720
|
+
"drops": []
|
|
41721
|
+
},
|
|
41722
|
+
"examples": [
|
|
41723
|
+
"await client.userDefinedFieldDefinitions.get('example-value')"
|
|
41724
|
+
],
|
|
41725
|
+
"permissions": "unknown",
|
|
41726
|
+
"pagination": {
|
|
41727
|
+
"mode": "none"
|
|
41728
|
+
},
|
|
41729
|
+
"resolution": null,
|
|
41730
|
+
"retry": {
|
|
41731
|
+
"preset": "retry-ffb3a9cb"
|
|
41732
|
+
},
|
|
41733
|
+
"errors": {
|
|
41734
|
+
"set": 3
|
|
41735
|
+
},
|
|
41736
|
+
"metadata": {
|
|
41737
|
+
"purpose": "Get one UserDefinedFieldDefinition by id.",
|
|
41738
|
+
"usage": "item: null on the 200 body maps to NotFoundError (vendor not-found signal).",
|
|
41739
|
+
"preferredWhen": "Preferred when the numeric id is already known; query by name when it is not.",
|
|
41740
|
+
"related": [],
|
|
41741
|
+
"args": "args[0] is the record id (number) Item GET returns the FULL vendor model — the vendor documents no field selection on single-record reads. For a slim record use an user_defined_field_definitions.query with includeFields.",
|
|
41742
|
+
"untrustedFields": [
|
|
41743
|
+
"description",
|
|
41744
|
+
"mergeVariableName",
|
|
41745
|
+
"name"
|
|
41746
|
+
]
|
|
41747
|
+
},
|
|
41748
|
+
"compact": null,
|
|
41749
|
+
"status": "tested"
|
|
41750
|
+
},
|
|
41751
|
+
{
|
|
41752
|
+
"id": "user_defined_field_definitions.getEntityInfo",
|
|
41753
|
+
"resource": "user_defined_field_definitions",
|
|
41754
|
+
"udfCapable": false,
|
|
41755
|
+
"operation": "getEntityInfo",
|
|
41756
|
+
"kind": "primitive",
|
|
41757
|
+
"endpoint": "GET /V1.0/UserDefinedFieldDefinitions/entityInformation",
|
|
41758
|
+
"effect": "read",
|
|
41759
|
+
"flags": [],
|
|
41760
|
+
"dryRun": false,
|
|
41761
|
+
"envelope": "EntityInformationResultModel",
|
|
41762
|
+
"inputSchema": {},
|
|
41763
|
+
"inputSchemaStrict": true,
|
|
41764
|
+
"outputSchema": {
|
|
41765
|
+
"type": "EntityInformationResultModel",
|
|
41766
|
+
"drops": []
|
|
41767
|
+
},
|
|
41768
|
+
"examples": [
|
|
41769
|
+
"await client.userDefinedFieldDefinitions.getEntityInfo()"
|
|
41770
|
+
],
|
|
41771
|
+
"permissions": "unknown",
|
|
41772
|
+
"pagination": {
|
|
41773
|
+
"mode": "none"
|
|
41774
|
+
},
|
|
41775
|
+
"resolution": null,
|
|
41776
|
+
"retry": {
|
|
41777
|
+
"preset": "retry-ffb3a9cb"
|
|
41778
|
+
},
|
|
41779
|
+
"errors": {
|
|
41780
|
+
"set": 0
|
|
41781
|
+
},
|
|
41782
|
+
"metadata": {
|
|
41783
|
+
"purpose": "Get the UserDefinedFieldDefinition capability metadata (canCreate/canUpdate/hasUserDefinedFields/...).",
|
|
41784
|
+
"usage": "Unwraps info{}; drives client-side capability checks.",
|
|
41785
|
+
"preferredWhen": null,
|
|
41786
|
+
"related": [
|
|
41787
|
+
"user_defined_field_definitions.getFieldInfo"
|
|
41788
|
+
],
|
|
41789
|
+
"untrustedFields": [
|
|
41790
|
+
"description",
|
|
41791
|
+
"mergeVariableName",
|
|
41792
|
+
"name"
|
|
41793
|
+
]
|
|
41794
|
+
},
|
|
41795
|
+
"compact": null,
|
|
41796
|
+
"status": "tested"
|
|
41797
|
+
},
|
|
41798
|
+
{
|
|
41799
|
+
"id": "user_defined_field_definitions.getFieldInfo",
|
|
41800
|
+
"resource": "user_defined_field_definitions",
|
|
41801
|
+
"udfCapable": false,
|
|
41802
|
+
"operation": "getFieldInfo",
|
|
41803
|
+
"kind": "primitive",
|
|
41804
|
+
"endpoint": "GET /V1.0/UserDefinedFieldDefinitions/entityInformation/fields",
|
|
41805
|
+
"effect": "read",
|
|
41806
|
+
"flags": [],
|
|
41807
|
+
"dryRun": false,
|
|
41808
|
+
"envelope": "FieldInformationResultModel",
|
|
41809
|
+
"inputSchema": {},
|
|
41810
|
+
"inputSchemaStrict": true,
|
|
41811
|
+
"outputSchema": {
|
|
41812
|
+
"type": "FieldInformationResultModel",
|
|
41813
|
+
"drops": []
|
|
41814
|
+
},
|
|
41815
|
+
"examples": [
|
|
41816
|
+
"await client.userDefinedFieldDefinitions.getFieldInfo()"
|
|
41817
|
+
],
|
|
41818
|
+
"permissions": "unknown",
|
|
41819
|
+
"pagination": {
|
|
41820
|
+
"mode": "none"
|
|
41821
|
+
},
|
|
41822
|
+
"resolution": null,
|
|
41823
|
+
"retry": {
|
|
41824
|
+
"preset": "retry-ffb3a9cb"
|
|
41825
|
+
},
|
|
41826
|
+
"errors": {
|
|
41827
|
+
"set": 0
|
|
41828
|
+
},
|
|
41829
|
+
"metadata": {
|
|
41830
|
+
"purpose": "Get the UserDefinedFieldDefinition field catalog (types, picklists, required, maxLength) — the full raw field dump (the largest read of the info trio; compact discovery: operations.fieldCatalog).",
|
|
41831
|
+
"usage": "Unwraps fields[]; full raw field dump — the largest read of the info trio (compact discovery: operations.fieldCatalog); the raw dump is also the basis for UDF handling.",
|
|
41832
|
+
"preferredWhen": null,
|
|
41833
|
+
"related": [
|
|
41834
|
+
"user_defined_field_definitions.getEntityInfo",
|
|
41835
|
+
"user_defined_field_definitions.getUdfInfo"
|
|
41836
|
+
],
|
|
41837
|
+
"untrustedFields": [
|
|
41838
|
+
"description",
|
|
41839
|
+
"mergeVariableName",
|
|
41840
|
+
"name"
|
|
41841
|
+
]
|
|
41842
|
+
},
|
|
41843
|
+
"compact": null,
|
|
41844
|
+
"status": "tested"
|
|
41845
|
+
},
|
|
41846
|
+
{
|
|
41847
|
+
"id": "user_defined_field_definitions.getUdfInfo",
|
|
41848
|
+
"resource": "user_defined_field_definitions",
|
|
41849
|
+
"udfCapable": false,
|
|
41850
|
+
"operation": "getUdfInfo",
|
|
41851
|
+
"kind": "primitive",
|
|
41852
|
+
"endpoint": "GET /V1.0/UserDefinedFieldDefinitions/entityInformation/userDefinedFields",
|
|
41853
|
+
"effect": "read",
|
|
41854
|
+
"flags": [],
|
|
41855
|
+
"dryRun": false,
|
|
41856
|
+
"envelope": "UserDefinedFieldInformationResultModel",
|
|
41857
|
+
"inputSchema": {},
|
|
41858
|
+
"inputSchemaStrict": true,
|
|
41859
|
+
"outputSchema": {
|
|
41860
|
+
"type": "UserDefinedFieldInformationResultModel",
|
|
41861
|
+
"drops": []
|
|
41862
|
+
},
|
|
41863
|
+
"examples": [
|
|
41864
|
+
"await client.userDefinedFieldDefinitions.getUdfInfo()"
|
|
41865
|
+
],
|
|
41866
|
+
"permissions": "unknown",
|
|
41867
|
+
"pagination": {
|
|
41868
|
+
"mode": "none"
|
|
41869
|
+
},
|
|
41870
|
+
"resolution": null,
|
|
41871
|
+
"retry": {
|
|
41872
|
+
"preset": "retry-ffb3a9cb"
|
|
41873
|
+
},
|
|
41874
|
+
"errors": {
|
|
41875
|
+
"set": 0
|
|
41876
|
+
},
|
|
41877
|
+
"metadata": {
|
|
41878
|
+
"purpose": "Get the UserDefinedFieldDefinition user-defined-field catalog.",
|
|
41879
|
+
"usage": "Unwraps fields[]; only meaningful where the entity is UDF-capable. (entity is not UDF-capable; catalog is expected empty).",
|
|
41880
|
+
"preferredWhen": null,
|
|
41881
|
+
"related": [
|
|
41882
|
+
"user_defined_field_definitions.getFieldInfo"
|
|
41883
|
+
],
|
|
41884
|
+
"untrustedFields": [
|
|
41885
|
+
"description",
|
|
41886
|
+
"mergeVariableName",
|
|
41887
|
+
"name"
|
|
41888
|
+
]
|
|
41889
|
+
},
|
|
41890
|
+
"compact": null,
|
|
41891
|
+
"status": "tested"
|
|
41892
|
+
},
|
|
41893
|
+
{
|
|
41894
|
+
"id": "user_defined_field_definitions.query",
|
|
41895
|
+
"resource": "user_defined_field_definitions",
|
|
41896
|
+
"udfCapable": false,
|
|
41897
|
+
"operation": "query",
|
|
41898
|
+
"kind": "primitive",
|
|
41899
|
+
"endpoint": "GET|POST /V1.0/UserDefinedFieldDefinitions/query",
|
|
41900
|
+
"effect": "read",
|
|
41901
|
+
"flags": [],
|
|
41902
|
+
"dryRun": false,
|
|
41903
|
+
"envelope": "QueryActionResult[<Model>,<Entity>]",
|
|
41904
|
+
"inputSchema": {
|
|
41905
|
+
"params": {
|
|
41906
|
+
"type": "object",
|
|
41907
|
+
"required": false,
|
|
41908
|
+
"description": "The query params object (CLOSED — unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 — NOT a page size), latest?: number (1-2500; the N highest-id rows — the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md §4; the same-process latest-walk count probes are briefly cached per client — a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch); the plain count op and aggregate stay fresh; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker … [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults — the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) — a truly unknown name is still refused); a refusal costs zero QUERY wire — the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way and carries the same fieldCheck opt-out; a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (absent = the client's labels option — OFF by default (the label pass costs a field-catalog read + up to 20 cold name reads per call; the MCP server (iit-mcp-autotask) enables the client labels option when it re-pins to this version (downstream)); true adds the row label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) — null, never missing, when the field is keyed with a null value, a 0 id or an unresolved value (a picklist 0 is labelled when the picklist defines it); a names summary appears only when something was left unlabelled (the 20 uncached name-read cap or an unresolved picklist value); false = raw ids, ~30% smaller on a full tickets row), via?: \"post\" | \"get\" (vendor GET has a 2048-char cap), acknowledgeUnscoped?: boolean (query verb only; a walk expected to read over 500 rows with no id scope in the filter is guarded — one pre-flight <resource>.count, and a count over 500 refuses with the typed SCOPE_REQUIRED before the walk; true walks the unscoped set anyway; a count that fails or is blind lets the walk run and the result's scopeNote says so), walk?: object (walk.maxRows: positive integer — (D6): the walk's TOTAL row cap — serves at most maxRows rows in total; the page size stays min(500, limit), so one vendor page may fetch more rows than maxRows and the surplus is sliced off (fetched, not served); the result's truncated flag — false only when the cursor is exhausted, true iff more rows exist past the cap (so an exact-multiple count with a live next page reports true); not combinable with latest) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or \"1,2,3\") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.",
|
|
41909
|
+
"properties": [
|
|
41910
|
+
{
|
|
41911
|
+
"name": "filter",
|
|
41912
|
+
"type": "FilterCondition[]",
|
|
41913
|
+
"optional": true
|
|
41914
|
+
},
|
|
41915
|
+
{
|
|
41916
|
+
"name": "limit",
|
|
41917
|
+
"type": "number",
|
|
41918
|
+
"optional": true,
|
|
41919
|
+
"default": 500
|
|
41920
|
+
},
|
|
41921
|
+
{
|
|
41922
|
+
"name": "latest",
|
|
41923
|
+
"type": "number",
|
|
41924
|
+
"optional": true
|
|
41925
|
+
},
|
|
41926
|
+
{
|
|
41927
|
+
"name": "noteChars",
|
|
41928
|
+
"type": "number",
|
|
41929
|
+
"optional": true
|
|
41930
|
+
},
|
|
41931
|
+
{
|
|
41932
|
+
"name": "includeFields",
|
|
41933
|
+
"type": "string[]",
|
|
41934
|
+
"optional": true
|
|
41935
|
+
},
|
|
41936
|
+
{
|
|
41937
|
+
"name": "fieldCheck",
|
|
41938
|
+
"type": "boolean",
|
|
41939
|
+
"optional": true,
|
|
41940
|
+
"default": true
|
|
41941
|
+
},
|
|
41942
|
+
{
|
|
41943
|
+
"name": "names",
|
|
41944
|
+
"type": "boolean",
|
|
41945
|
+
"optional": true
|
|
41946
|
+
},
|
|
41947
|
+
{
|
|
41948
|
+
"name": "via",
|
|
41949
|
+
"type": "\"post\" | \"get\"",
|
|
41950
|
+
"optional": true
|
|
41951
|
+
},
|
|
41952
|
+
{
|
|
41953
|
+
"name": "acknowledgeUnscoped",
|
|
41954
|
+
"type": "boolean",
|
|
41955
|
+
"optional": true
|
|
41956
|
+
},
|
|
41957
|
+
{
|
|
41958
|
+
"name": "walk",
|
|
41959
|
+
"type": "object",
|
|
41960
|
+
"optional": true
|
|
41961
|
+
}
|
|
41962
|
+
]
|
|
41963
|
+
}
|
|
41964
|
+
},
|
|
41965
|
+
"inputSchemaStrict": true,
|
|
41966
|
+
"outputSchema": {
|
|
41967
|
+
"type": "QueryActionResult[<Model>,<Entity>]",
|
|
41968
|
+
"drops": []
|
|
41969
|
+
},
|
|
41970
|
+
"examples": [
|
|
41971
|
+
"await client.userDefinedFieldDefinitions.query({ filter: [{ field: 'name', op: 'eq', value: 'example' }], limit: 500 })"
|
|
41972
|
+
],
|
|
41973
|
+
"permissions": "unknown",
|
|
41974
|
+
"pagination": {
|
|
41975
|
+
"mode": "cursor",
|
|
41976
|
+
"vendorDefault": 10,
|
|
41977
|
+
"vendorMax": 500,
|
|
41978
|
+
"pageGuard": 1000,
|
|
41979
|
+
"queryBounded": {
|
|
41980
|
+
"default": 500,
|
|
41981
|
+
"max": 2500
|
|
41982
|
+
}
|
|
41983
|
+
},
|
|
41984
|
+
"resolution": null,
|
|
41985
|
+
"retry": {
|
|
41986
|
+
"preset": "retry-ffb3a9cb"
|
|
41987
|
+
},
|
|
41988
|
+
"errors": {
|
|
41989
|
+
"set": 4
|
|
41990
|
+
},
|
|
41991
|
+
"metadata": {
|
|
41992
|
+
"purpose": "Query UserDefinedFieldDefinition records with a JSON filter.",
|
|
41993
|
+
"usage": "Server-side pagination: one call walks the vendor cursor internally (page 1 POSTs the QueryModel body with MaxRecords = the walk's internal page size (at most 500; the default POST path — `via: 'get'` issues a GET on page 1); later pages POST the SAME body — IncludeFields, MaxRecords and the preserved filter — to the absolute vendor cursor, rebased to the client base URL; the vendor honours IncludeFields on a continuation and ignores MaxRecords there, so a later page carries the vendor's own page size) until the limit is met or the cursor is null; 1000-page guard (hasMore stays true at the guard). queryAll is the unbounded raw walk — only when you need the ENTIRE set and accept a large payload; default to the bounded query op. noteChars: N (integer >= 1) is an opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose — the same set the server wraps): each capped value = the first N chars + the explicit marker … [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result (zero wire — response-side only). latest: N returns the N highest-id rows (id-descending): the vendor has no sort parameter — this is the only ordering channel, and a date window in `filter` narrows the cost; count-anchored — C ≤ 2500 → one count + a ≤6-page walk of the matching set, C > 2500 → count probes + an id-threshold window (≤64 probes; LATEST_THRESHOLD_UNRESOLVED on budget exhaustion), a blind count → a bounded walk with the blind-surface stamp (LATEST_WINDOW_INCOMPLETE on a truncated walk). Explicit walk.maxRows independently sets the TOTAL returned-row cap (including export-sized walks); the ordinary limit is still validated in 1..2500 and only bounds the internal page size for this form. hasMore and truncated remain true at the page guard or while a cursor or unserved fetched rows remain. Self-resource prefixes are accepted in filter fields and includeFields; dotted UDF names are always refused before metadata or vendor requests, never rewritten to another tenant UDF.",
|
|
41994
|
+
"preferredWhen": "Default for filtered reads (the bounded query op). queryAll is the unbounded raw walk — only when you need the ENTIRE set and accept a large payload; default to the bounded query op. Prefer an includeFields subset over the full model (field names via operations.fieldCatalog). latest: N is the latest-N rows (id-descending) when the newest rows are the goal (the vendor has no sort — count-anchored, docs/API.md §4). Prefer a hand-listed includeFields for common narrow reads (removed the closed fieldsPreset presets — the v1 billing_join field list for billing_items.query, if you need it, is: companyID, ticketID, projectID, timeEntryID, contractServiceID, contractID, billingCodeID, expenseItemID, itemDate, quantity, rate, extendedPrice, totalAmount, nonBillable); noteChars: N caps the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose) to N chars each with the explicit … [+N chars truncated] marker (opt-in; the raw result when absent).",
|
|
41995
|
+
"related": [
|
|
41996
|
+
"user_defined_field_definitions.get"
|
|
41997
|
+
],
|
|
41998
|
+
"args": "args[0] is a params object: { filter?: FilterCondition[], limit?: total cap (default 500, max 2500; server-side pagination), latest?: number (1-2500 — the N highest-id rows; the vendor has no sort parameter, so this is a count-anchored mechanism — see docs/API.md §4; coexists with limit only when limit >= latest), noteChars?: number (integer >= 1 — opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker … [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result) maxRecords?: page size — raw SDK `queryAll`/`query` walks only (this bounded query ignores it; the invoke bag refuses it — pass limit), includeFields?: string[], fieldCheck?: boolean (default true — the pre-request field-name check on includeFields names and filter condition fields; false disables it — consumed by the invoke router, never sent to the vendor), via?: \"post\" | \"get\" (the wire method; the vendor GET has a 2048-char cap), acknowledgeUnscoped?: boolean (query verb only; a walk expected over 500 rows with no id scope in the filter is guarded — one pre-flight <resource>.count, and a count over 500 refuses with the typed SCOPE_REQUIRED before the walk; true walks the unscoped set anyway; a count that fails or is blind lets the walk run and the result’s scopeNote says so), walk?: { maxRows: positive integer (D6: the walk’s TOTAL row cap — serves at most maxRows rows in total; the page size stays min(500, limit), so one vendor page may fetch more rows than maxRows and the surplus is sliced off (fetched, not served); the result’s truncated flag — false only when the cursor is exhausted, true iff more rows exist past the cap (so an exact-multiple count with a live next page reports true); not combinable with latest) } }. Filter grammar: 13 operators: eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn (in/notIn: array or '1,2,3') + and/or grouping (no not-group). Field names in vendor API casing — get them via operations.fieldCatalog. Caps: 500 OR-conditions / 1 UDF / 8000 chars. By default the FULL vendor model is returned (all fields). To slim the payload for context savings pass includeFields with the exact vendor field names you need (discover them via operations.fieldCatalog); only those fields + id come back. The subset persists across the internal page walk.",
|
|
41999
|
+
"untrustedFields": [
|
|
42000
|
+
"description",
|
|
42001
|
+
"mergeVariableName",
|
|
42002
|
+
"name"
|
|
42003
|
+
]
|
|
42004
|
+
},
|
|
42005
|
+
"compact": null,
|
|
42006
|
+
"status": "tested"
|
|
42007
|
+
},
|
|
42008
|
+
{
|
|
42009
|
+
"id": "user_defined_field_definitions.update",
|
|
42010
|
+
"resource": "user_defined_field_definitions",
|
|
42011
|
+
"udfCapable": false,
|
|
42012
|
+
"operation": "update",
|
|
42013
|
+
"kind": "primitive",
|
|
42014
|
+
"endpoint": "PUT|PATCH /V1.0/UserDefinedFieldDefinitions",
|
|
42015
|
+
"effect": "write",
|
|
42016
|
+
"flags": [
|
|
42017
|
+
"idempotent"
|
|
42018
|
+
],
|
|
42019
|
+
"dryRun": true,
|
|
42020
|
+
"envelope": "OperationResultModel",
|
|
42021
|
+
"inputSchema": {
|
|
42022
|
+
"id": {
|
|
42023
|
+
"type": "string | number",
|
|
42024
|
+
"required": true,
|
|
42025
|
+
"description": "The record id (number, or a canonical integer string — ids beyond 2^53 are supported via the string form)."
|
|
42026
|
+
},
|
|
42027
|
+
"data": {
|
|
42028
|
+
"type": "object",
|
|
42029
|
+
"required": true,
|
|
42030
|
+
"description": "The record payload (vendor model fields)."
|
|
42031
|
+
}
|
|
42032
|
+
},
|
|
42033
|
+
"inputSchemaStrict": true,
|
|
42034
|
+
"outputSchema": {
|
|
42035
|
+
"type": "OperationResultModel",
|
|
42036
|
+
"drops": []
|
|
42037
|
+
},
|
|
42038
|
+
"examples": [
|
|
42039
|
+
"await client.userDefinedFieldDefinitions.update('example-value', { name: 'example' }, { dryRun: true })"
|
|
42040
|
+
],
|
|
42041
|
+
"permissions": "unknown",
|
|
42042
|
+
"pagination": {
|
|
42043
|
+
"mode": "none"
|
|
42044
|
+
},
|
|
42045
|
+
"resolution": null,
|
|
42046
|
+
"retry": {
|
|
42047
|
+
"preset": "retry-1849870d"
|
|
42048
|
+
},
|
|
42049
|
+
"errors": {
|
|
42050
|
+
"set": 1
|
|
42051
|
+
},
|
|
42052
|
+
"metadata": {
|
|
42053
|
+
"purpose": "Update a UDF definition.",
|
|
42054
|
+
"usage": "Issues PUT (vendor tolerates PATCH for the same endpoint). Stale check via lastModifiedDate where present. Vendor constraints: `dataType` and `udfType` cannot be changed; `isFieldMapping` is immutable (a mapped field only accepts `isActive`/`sortOrder` updates); a `List` UDF's `defaultValue` is a list item's `valueForDisplay` (set it only after the items exist). The collection PUT validates the FULL model (vendor V2): a partial body is merged into the current record (one GET — also the stale-object guard's read) before the PUT; explicit nulls send null, omitted fields keep the current value. Pass raw: true in the opts bag to send the body as-is (no merge).",
|
|
42055
|
+
"preferredWhen": "Preferred over create or delete when the record exists and only some fields change.",
|
|
42056
|
+
"related": [
|
|
42057
|
+
"user_defined_field_definitions.get"
|
|
42058
|
+
],
|
|
42059
|
+
"collectionUpdate": true,
|
|
42060
|
+
"untrustedFields": [
|
|
42061
|
+
"description",
|
|
42062
|
+
"mergeVariableName",
|
|
42063
|
+
"name"
|
|
42064
|
+
],
|
|
42065
|
+
"accountWide": true
|
|
42066
|
+
},
|
|
42067
|
+
"compact": null,
|
|
42068
|
+
"status": "tested"
|
|
42069
|
+
},
|
|
42070
|
+
{
|
|
42071
|
+
"id": "user_defined_field_list_items.count",
|
|
42072
|
+
"resource": "user_defined_field_list_items",
|
|
42073
|
+
"udfCapable": false,
|
|
42074
|
+
"operation": "count",
|
|
42075
|
+
"kind": "primitive",
|
|
42076
|
+
"endpoint": "GET|POST /V1.0/UserDefinedFieldListItems/query/count",
|
|
42077
|
+
"effect": "read",
|
|
42078
|
+
"flags": [],
|
|
42079
|
+
"dryRun": false,
|
|
42080
|
+
"envelope": "QueryCountResultModel",
|
|
42081
|
+
"inputSchema": {
|
|
42082
|
+
"params": {
|
|
42083
|
+
"type": "object",
|
|
42084
|
+
"required": false,
|
|
42085
|
+
"description": "The query params object (CLOSED — unknown keys are refused pre-request): { filter?: FilterCondition[], fieldCheck?: boolean } — filter is the only wire parameter (the count endpoint takes no MaxRecords/IncludeFields; fieldCheck is consumed by the invoke router — never sent to the vendor). Filter condition field names are name-checked pre-request the same way as the query bag: a refusal costs zero /query/count wire (the cold fieldCache may cost the one authority metadata GET first). fieldCheck: false disables the name check (a non-boolean is refused pre-request; the shape/grammar checks always run) — the opt-out works on the count verb too.",
|
|
42086
|
+
"properties": [
|
|
42087
|
+
{
|
|
42088
|
+
"name": "filter",
|
|
42089
|
+
"type": "FilterCondition[]",
|
|
42090
|
+
"optional": true
|
|
42091
|
+
},
|
|
42092
|
+
{
|
|
42093
|
+
"name": "fieldCheck",
|
|
42094
|
+
"type": "boolean",
|
|
42095
|
+
"optional": true
|
|
42096
|
+
}
|
|
42097
|
+
]
|
|
42098
|
+
}
|
|
42099
|
+
},
|
|
42100
|
+
"inputSchemaStrict": true,
|
|
42101
|
+
"outputSchema": {
|
|
42102
|
+
"type": "QueryCountResultModel",
|
|
42103
|
+
"drops": []
|
|
42104
|
+
},
|
|
42105
|
+
"examples": [
|
|
42106
|
+
"await client.userDefinedFieldListItems.count({ filter: [{ field: 'name', op: 'eq', value: 'example' }] })"
|
|
42107
|
+
],
|
|
42108
|
+
"permissions": "unknown",
|
|
42109
|
+
"pagination": {
|
|
42110
|
+
"mode": "none"
|
|
42111
|
+
},
|
|
42112
|
+
"resolution": null,
|
|
42113
|
+
"retry": {
|
|
42114
|
+
"preset": "retry-ffb3a9cb"
|
|
42115
|
+
},
|
|
42116
|
+
"errors": {
|
|
42117
|
+
"set": 0
|
|
42118
|
+
},
|
|
42119
|
+
"metadata": {
|
|
42120
|
+
"purpose": "Count user-defined field list item records matching a JSON filter.",
|
|
42121
|
+
"usage": "Unwraps queryCount; returns a plain number.",
|
|
42122
|
+
"preferredWhen": null,
|
|
42123
|
+
"related": [
|
|
42124
|
+
"user_defined_field_list_items.query"
|
|
42125
|
+
],
|
|
42126
|
+
"args": "args[0] is a params object (CLOSED — unknown keys are refused pre-request): { filter?: FilterCondition[], fieldCheck?: boolean } — filter is the only parameter sent to the vendor (the count endpoint takes no MaxRecords/IncludeFields; fieldCheck is consumed by the invoke router — never sent to the vendor). Filter condition field names are name-checked pre-request the same way as the query bag: a refusal costs zero /query/count wire (the cold fieldCache may cost the one authority metadata GET first). fieldCheck: false disables the name check (a non-boolean is refused pre-request; the shape/grammar checks always run) — the opt-out works on the count verb too. Filter grammar: 13 operators: eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn (in/notIn: array or '1,2,3') + and/or grouping (no not-group). Field names in vendor API casing — get them via operations.fieldCatalog. Caps: 500 OR-conditions / 1 UDF / 8000 chars.",
|
|
42127
|
+
"untrustedFields": [
|
|
42128
|
+
"valueForDisplay",
|
|
42129
|
+
"valueForExport"
|
|
42130
|
+
]
|
|
42131
|
+
},
|
|
42132
|
+
"compact": null,
|
|
42133
|
+
"status": "tested"
|
|
42134
|
+
},
|
|
42135
|
+
{
|
|
42136
|
+
"id": "user_defined_field_list_items.create",
|
|
42137
|
+
"resource": "user_defined_field_list_items",
|
|
42138
|
+
"udfCapable": false,
|
|
42139
|
+
"operation": "create",
|
|
42140
|
+
"kind": "primitive",
|
|
42141
|
+
"endpoint": "POST /V1.0/UserDefinedFields/{parentId}/ListItems",
|
|
42142
|
+
"effect": "write",
|
|
42143
|
+
"flags": [],
|
|
42144
|
+
"dryRun": true,
|
|
42145
|
+
"envelope": "OperationResultModel",
|
|
42146
|
+
"inputSchema": {
|
|
42147
|
+
"parentId": {
|
|
42148
|
+
"type": "string | number",
|
|
42149
|
+
"required": true,
|
|
42150
|
+
"description": "The parent record id (parent-scoped collection; number, or a canonical integer string)."
|
|
42151
|
+
},
|
|
42152
|
+
"data": {
|
|
42153
|
+
"type": "object",
|
|
42154
|
+
"required": true,
|
|
42155
|
+
"description": "The record payload (vendor model fields)."
|
|
42156
|
+
}
|
|
42157
|
+
},
|
|
42158
|
+
"inputSchemaStrict": true,
|
|
42159
|
+
"outputSchema": {
|
|
42160
|
+
"type": "OperationResultModel",
|
|
42161
|
+
"drops": []
|
|
42162
|
+
},
|
|
42163
|
+
"examples": [
|
|
42164
|
+
"await client.userDefinedFieldListItems.create('example-value', { name: 'example' }, { dryRun: true })"
|
|
42165
|
+
],
|
|
42166
|
+
"permissions": "unknown",
|
|
42167
|
+
"pagination": {
|
|
42168
|
+
"mode": "none"
|
|
42169
|
+
},
|
|
42170
|
+
"resolution": null,
|
|
42171
|
+
"retry": {
|
|
42172
|
+
"preset": "retry-c5657094"
|
|
42173
|
+
},
|
|
42174
|
+
"errors": {
|
|
42175
|
+
"set": 1
|
|
42176
|
+
},
|
|
42177
|
+
"metadata": {
|
|
42178
|
+
"purpose": "Create a UDF list item.",
|
|
42179
|
+
"usage": "Returns OperationResultModel.itemId (the new id); the full record is not returned — follow up with get where needed. Parent-scoped: parentId is a path parameter. `valueForDisplay` and `valueForExport` are both required and must be unique within the UDF; `isActive` defaults to true (there is no vendor delete — removal is soft via `isActive`).",
|
|
42180
|
+
"preferredWhen": "Only for a record that does not exist yet; prefer update for an id you already have.",
|
|
42181
|
+
"related": [
|
|
42182
|
+
"user_defined_field_list_items.update"
|
|
42183
|
+
],
|
|
42184
|
+
"deleteBoundary": {
|
|
42185
|
+
"resource": "user_defined_field_list_items",
|
|
42186
|
+
"note": "the vendor defines no DELETE for user_defined_field_list_items (spec-derived: the vendored api-docs.json defines no DELETE on the standalone or parent-scoped ListItems paths) — a picklist value cannot be deleted through the API; deactivation is via isActive (vendor soft-removal); hard cleanup is UI-only.",
|
|
42187
|
+
"proof": "spec-derived"
|
|
42188
|
+
},
|
|
42189
|
+
"untrustedFields": [
|
|
42190
|
+
"valueForDisplay",
|
|
42191
|
+
"valueForExport"
|
|
42192
|
+
],
|
|
42193
|
+
"accountWide": true
|
|
42194
|
+
},
|
|
42195
|
+
"compact": null,
|
|
42196
|
+
"status": "tested"
|
|
42197
|
+
},
|
|
42198
|
+
{
|
|
42199
|
+
"id": "user_defined_field_list_items.get",
|
|
42200
|
+
"resource": "user_defined_field_list_items",
|
|
42201
|
+
"udfCapable": false,
|
|
42202
|
+
"operation": "get",
|
|
42203
|
+
"kind": "primitive",
|
|
42204
|
+
"endpoint": "GET /V1.0/UserDefinedFields/{parentId}/ListItems/{id}",
|
|
42205
|
+
"effect": "read",
|
|
42206
|
+
"flags": [],
|
|
42207
|
+
"dryRun": false,
|
|
42208
|
+
"envelope": "ItemQueryResultModel[UserDefinedFieldListItemModel,UserDefinedFieldListItem]",
|
|
42209
|
+
"inputSchema": {
|
|
42210
|
+
"parentId": {
|
|
42211
|
+
"type": "string | number",
|
|
42212
|
+
"required": true,
|
|
42213
|
+
"description": "The parent record id (parent-scoped collection; number, or a canonical integer string)."
|
|
42214
|
+
},
|
|
42215
|
+
"id": {
|
|
42216
|
+
"type": "string | number",
|
|
42217
|
+
"required": true,
|
|
42218
|
+
"description": "The record id (number, or a canonical integer string — ids beyond 2^53 are supported via the string form)."
|
|
42219
|
+
},
|
|
42220
|
+
"opts": {
|
|
42221
|
+
"type": "object",
|
|
42222
|
+
"required": false,
|
|
42223
|
+
"description": "The read options bag (CLOSED): { fresh?: boolean } — fresh: true bypasses the read-cache lookup and refreshes the entry with the live response. Omitted: the cached read (default unchanged). A positional fresh via invoke is REFUSED (typed error, zero wire — the fresh invoke option is the only spelling); the typed method get(id, { fresh: true }) is unchanged.",
|
|
42224
|
+
"properties": [
|
|
42225
|
+
{
|
|
42226
|
+
"name": "fresh",
|
|
42227
|
+
"type": "boolean",
|
|
42228
|
+
"optional": true
|
|
42229
|
+
}
|
|
42230
|
+
]
|
|
42231
|
+
}
|
|
42232
|
+
},
|
|
42233
|
+
"inputSchemaStrict": true,
|
|
42234
|
+
"outputSchema": {
|
|
42235
|
+
"type": "ItemQueryResultModel[UserDefinedFieldListItemModel,UserDefinedFieldListItem]",
|
|
42236
|
+
"drops": []
|
|
42237
|
+
},
|
|
42238
|
+
"examples": [
|
|
42239
|
+
"await client.userDefinedFieldListItems.get('example-value', 'example-value')"
|
|
42240
|
+
],
|
|
42241
|
+
"permissions": "unknown",
|
|
42242
|
+
"pagination": {
|
|
42243
|
+
"mode": "none"
|
|
42244
|
+
},
|
|
42245
|
+
"resolution": null,
|
|
42246
|
+
"retry": {
|
|
42247
|
+
"preset": "retry-ffb3a9cb"
|
|
42248
|
+
},
|
|
42249
|
+
"errors": {
|
|
42250
|
+
"set": 3
|
|
42251
|
+
},
|
|
42252
|
+
"metadata": {
|
|
42253
|
+
"purpose": "Get one UserDefinedFieldListItem by id.",
|
|
42254
|
+
"usage": "item: null on the 200 body maps to NotFoundError (vendor not-found signal). Parent-scoped: parentId + id.",
|
|
42255
|
+
"preferredWhen": "Preferred when the numeric id is known with the parent definition id; query by udfFieldId when it is not.",
|
|
42256
|
+
"related": [],
|
|
42257
|
+
"args": "args are (parentId: number, id: number) Item GET returns the FULL vendor model — the vendor documents no field selection on single-record reads. For a slim record use an user_defined_field_list_items.query with includeFields.",
|
|
42258
|
+
"untrustedFields": [
|
|
42259
|
+
"valueForDisplay",
|
|
42260
|
+
"valueForExport"
|
|
42261
|
+
]
|
|
42262
|
+
},
|
|
42263
|
+
"compact": null,
|
|
42264
|
+
"status": "tested"
|
|
42265
|
+
},
|
|
42266
|
+
{
|
|
42267
|
+
"id": "user_defined_field_list_items.getEntityInfo",
|
|
42268
|
+
"resource": "user_defined_field_list_items",
|
|
42269
|
+
"udfCapable": false,
|
|
42270
|
+
"operation": "getEntityInfo",
|
|
42271
|
+
"kind": "primitive",
|
|
42272
|
+
"endpoint": "GET /V1.0/UserDefinedFieldListItems/entityInformation",
|
|
42273
|
+
"effect": "read",
|
|
42274
|
+
"flags": [],
|
|
42275
|
+
"dryRun": false,
|
|
42276
|
+
"envelope": "EntityInformationResultModel",
|
|
42277
|
+
"inputSchema": {},
|
|
42278
|
+
"inputSchemaStrict": true,
|
|
42279
|
+
"outputSchema": {
|
|
42280
|
+
"type": "EntityInformationResultModel",
|
|
42281
|
+
"drops": []
|
|
42282
|
+
},
|
|
42283
|
+
"examples": [
|
|
42284
|
+
"await client.userDefinedFieldListItems.getEntityInfo()"
|
|
42285
|
+
],
|
|
42286
|
+
"permissions": "unknown",
|
|
42287
|
+
"pagination": {
|
|
42288
|
+
"mode": "none"
|
|
42289
|
+
},
|
|
42290
|
+
"resolution": null,
|
|
42291
|
+
"retry": {
|
|
42292
|
+
"preset": "retry-ffb3a9cb"
|
|
42293
|
+
},
|
|
42294
|
+
"errors": {
|
|
42295
|
+
"set": 0
|
|
42296
|
+
},
|
|
42297
|
+
"metadata": {
|
|
42298
|
+
"purpose": "Get the UserDefinedFieldListItem capability metadata (canCreate/canUpdate/hasUserDefinedFields/...).",
|
|
42299
|
+
"usage": "Unwraps info{}; drives client-side capability checks.",
|
|
42300
|
+
"preferredWhen": null,
|
|
42301
|
+
"related": [
|
|
42302
|
+
"user_defined_field_list_items.getFieldInfo"
|
|
42303
|
+
],
|
|
42304
|
+
"untrustedFields": [
|
|
42305
|
+
"valueForDisplay",
|
|
42306
|
+
"valueForExport"
|
|
42307
|
+
]
|
|
42308
|
+
},
|
|
42309
|
+
"compact": null,
|
|
42310
|
+
"status": "tested"
|
|
42311
|
+
},
|
|
42312
|
+
{
|
|
42313
|
+
"id": "user_defined_field_list_items.getFieldInfo",
|
|
42314
|
+
"resource": "user_defined_field_list_items",
|
|
42315
|
+
"udfCapable": false,
|
|
42316
|
+
"operation": "getFieldInfo",
|
|
42317
|
+
"kind": "primitive",
|
|
42318
|
+
"endpoint": "GET /V1.0/UserDefinedFieldListItems/entityInformation/fields",
|
|
42319
|
+
"effect": "read",
|
|
42320
|
+
"flags": [],
|
|
42321
|
+
"dryRun": false,
|
|
42322
|
+
"envelope": "FieldInformationResultModel",
|
|
42323
|
+
"inputSchema": {},
|
|
42324
|
+
"inputSchemaStrict": true,
|
|
42325
|
+
"outputSchema": {
|
|
42326
|
+
"type": "FieldInformationResultModel",
|
|
42327
|
+
"drops": []
|
|
42328
|
+
},
|
|
42329
|
+
"examples": [
|
|
42330
|
+
"await client.userDefinedFieldListItems.getFieldInfo()"
|
|
42331
|
+
],
|
|
42332
|
+
"permissions": "unknown",
|
|
42333
|
+
"pagination": {
|
|
42334
|
+
"mode": "none"
|
|
42335
|
+
},
|
|
42336
|
+
"resolution": null,
|
|
42337
|
+
"retry": {
|
|
42338
|
+
"preset": "retry-ffb3a9cb"
|
|
42339
|
+
},
|
|
42340
|
+
"errors": {
|
|
42341
|
+
"set": 0
|
|
42342
|
+
},
|
|
42343
|
+
"metadata": {
|
|
42344
|
+
"purpose": "Get the UserDefinedFieldListItem field catalog (types, picklists, required, maxLength) — the full raw field dump (the largest read of the info trio; compact discovery: operations.fieldCatalog).",
|
|
42345
|
+
"usage": "Unwraps fields[]; full raw field dump — the largest read of the info trio (compact discovery: operations.fieldCatalog); the raw dump is also the basis for UDF handling.",
|
|
42346
|
+
"preferredWhen": null,
|
|
42347
|
+
"related": [
|
|
42348
|
+
"user_defined_field_list_items.getEntityInfo",
|
|
42349
|
+
"user_defined_field_list_items.getUdfInfo"
|
|
42350
|
+
],
|
|
42351
|
+
"untrustedFields": [
|
|
42352
|
+
"valueForDisplay",
|
|
42353
|
+
"valueForExport"
|
|
42354
|
+
]
|
|
42355
|
+
},
|
|
42356
|
+
"compact": null,
|
|
42357
|
+
"status": "tested"
|
|
42358
|
+
},
|
|
42359
|
+
{
|
|
42360
|
+
"id": "user_defined_field_list_items.getUdfInfo",
|
|
42361
|
+
"resource": "user_defined_field_list_items",
|
|
42362
|
+
"udfCapable": false,
|
|
42363
|
+
"operation": "getUdfInfo",
|
|
42364
|
+
"kind": "primitive",
|
|
42365
|
+
"endpoint": "GET /V1.0/UserDefinedFieldListItems/entityInformation/userDefinedFields",
|
|
42366
|
+
"effect": "read",
|
|
42367
|
+
"flags": [],
|
|
42368
|
+
"dryRun": false,
|
|
42369
|
+
"envelope": "UserDefinedFieldInformationResultModel",
|
|
42370
|
+
"inputSchema": {},
|
|
42371
|
+
"inputSchemaStrict": true,
|
|
42372
|
+
"outputSchema": {
|
|
42373
|
+
"type": "UserDefinedFieldInformationResultModel",
|
|
42374
|
+
"drops": []
|
|
42375
|
+
},
|
|
42376
|
+
"examples": [
|
|
42377
|
+
"await client.userDefinedFieldListItems.getUdfInfo()"
|
|
42378
|
+
],
|
|
42379
|
+
"permissions": "unknown",
|
|
42380
|
+
"pagination": {
|
|
42381
|
+
"mode": "none"
|
|
42382
|
+
},
|
|
42383
|
+
"resolution": null,
|
|
42384
|
+
"retry": {
|
|
42385
|
+
"preset": "retry-ffb3a9cb"
|
|
42386
|
+
},
|
|
42387
|
+
"errors": {
|
|
42388
|
+
"set": 0
|
|
42389
|
+
},
|
|
42390
|
+
"metadata": {
|
|
42391
|
+
"purpose": "Get the UserDefinedFieldListItem user-defined-field catalog.",
|
|
42392
|
+
"usage": "Unwraps fields[]; only meaningful where the entity is UDF-capable. (entity is not UDF-capable; catalog is expected empty).",
|
|
42393
|
+
"preferredWhen": null,
|
|
42394
|
+
"related": [
|
|
42395
|
+
"user_defined_field_list_items.getFieldInfo"
|
|
42396
|
+
],
|
|
42397
|
+
"untrustedFields": [
|
|
42398
|
+
"valueForDisplay",
|
|
42399
|
+
"valueForExport"
|
|
42400
|
+
]
|
|
42401
|
+
},
|
|
42402
|
+
"compact": null,
|
|
42403
|
+
"status": "tested"
|
|
42404
|
+
},
|
|
42405
|
+
{
|
|
42406
|
+
"id": "user_defined_field_list_items.query",
|
|
42407
|
+
"resource": "user_defined_field_list_items",
|
|
42408
|
+
"udfCapable": false,
|
|
42409
|
+
"operation": "query",
|
|
42410
|
+
"kind": "primitive",
|
|
42411
|
+
"endpoint": "GET|POST /V1.0/UserDefinedFieldListItems/query",
|
|
42412
|
+
"effect": "read",
|
|
42413
|
+
"flags": [],
|
|
42414
|
+
"dryRun": false,
|
|
42415
|
+
"envelope": "QueryActionResult[<Model>,<Entity>]",
|
|
42416
|
+
"inputSchema": {
|
|
42417
|
+
"params": {
|
|
42418
|
+
"type": "object",
|
|
42419
|
+
"required": false,
|
|
42420
|
+
"description": "The query params object (CLOSED — unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 — NOT a page size), latest?: number (1-2500; the N highest-id rows — the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md §4; the same-process latest-walk count probes are briefly cached per client — a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch); the plain count op and aggregate stay fresh; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker … [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults — the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) — a truly unknown name is still refused); a refusal costs zero QUERY wire — the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way and carries the same fieldCheck opt-out; a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (absent = the client's labels option — OFF by default (the label pass costs a field-catalog read + up to 20 cold name reads per call; the MCP server (iit-mcp-autotask) enables the client labels option when it re-pins to this version (downstream)); true adds the row label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) — null, never missing, when the field is keyed with a null value, a 0 id or an unresolved value (a picklist 0 is labelled when the picklist defines it); a names summary appears only when something was left unlabelled (the 20 uncached name-read cap or an unresolved picklist value); false = raw ids, ~30% smaller on a full tickets row), via?: \"post\" | \"get\" (vendor GET has a 2048-char cap), acknowledgeUnscoped?: boolean (query verb only; a walk expected to read over 500 rows with no id scope in the filter is guarded — one pre-flight <resource>.count, and a count over 500 refuses with the typed SCOPE_REQUIRED before the walk; true walks the unscoped set anyway; a count that fails or is blind lets the walk run and the result's scopeNote says so), walk?: object (walk.maxRows: positive integer — (D6): the walk's TOTAL row cap — serves at most maxRows rows in total; the page size stays min(500, limit), so one vendor page may fetch more rows than maxRows and the surplus is sliced off (fetched, not served); the result's truncated flag — false only when the cursor is exhausted, true iff more rows exist past the cap (so an exact-multiple count with a live next page reports true); not combinable with latest) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or \"1,2,3\") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.",
|
|
42421
|
+
"properties": [
|
|
42422
|
+
{
|
|
42423
|
+
"name": "filter",
|
|
42424
|
+
"type": "FilterCondition[]",
|
|
42425
|
+
"optional": true
|
|
42426
|
+
},
|
|
42427
|
+
{
|
|
42428
|
+
"name": "limit",
|
|
42429
|
+
"type": "number",
|
|
42430
|
+
"optional": true,
|
|
42431
|
+
"default": 500
|
|
42432
|
+
},
|
|
42433
|
+
{
|
|
42434
|
+
"name": "latest",
|
|
42435
|
+
"type": "number",
|
|
42436
|
+
"optional": true
|
|
42437
|
+
},
|
|
42438
|
+
{
|
|
42439
|
+
"name": "noteChars",
|
|
42440
|
+
"type": "number",
|
|
42441
|
+
"optional": true
|
|
42442
|
+
},
|
|
42443
|
+
{
|
|
42444
|
+
"name": "includeFields",
|
|
42445
|
+
"type": "string[]",
|
|
42446
|
+
"optional": true
|
|
42447
|
+
},
|
|
42448
|
+
{
|
|
42449
|
+
"name": "fieldCheck",
|
|
42450
|
+
"type": "boolean",
|
|
42451
|
+
"optional": true,
|
|
42452
|
+
"default": true
|
|
42453
|
+
},
|
|
42454
|
+
{
|
|
42455
|
+
"name": "names",
|
|
42456
|
+
"type": "boolean",
|
|
42457
|
+
"optional": true
|
|
42458
|
+
},
|
|
42459
|
+
{
|
|
42460
|
+
"name": "via",
|
|
42461
|
+
"type": "\"post\" | \"get\"",
|
|
42462
|
+
"optional": true
|
|
42463
|
+
},
|
|
42464
|
+
{
|
|
42465
|
+
"name": "acknowledgeUnscoped",
|
|
42466
|
+
"type": "boolean",
|
|
42467
|
+
"optional": true
|
|
42468
|
+
},
|
|
42469
|
+
{
|
|
42470
|
+
"name": "walk",
|
|
42471
|
+
"type": "object",
|
|
42472
|
+
"optional": true
|
|
42473
|
+
}
|
|
42474
|
+
]
|
|
42475
|
+
}
|
|
42476
|
+
},
|
|
42477
|
+
"inputSchemaStrict": true,
|
|
42478
|
+
"outputSchema": {
|
|
42479
|
+
"type": "QueryActionResult[<Model>,<Entity>]",
|
|
42480
|
+
"drops": []
|
|
42481
|
+
},
|
|
42482
|
+
"examples": [
|
|
42483
|
+
"await client.userDefinedFieldListItems.query({ filter: [{ field: 'name', op: 'eq', value: 'example' }], limit: 500 })"
|
|
42484
|
+
],
|
|
42485
|
+
"permissions": "unknown",
|
|
42486
|
+
"pagination": {
|
|
42487
|
+
"mode": "cursor",
|
|
42488
|
+
"vendorDefault": 10,
|
|
42489
|
+
"vendorMax": 500,
|
|
42490
|
+
"pageGuard": 1000,
|
|
42491
|
+
"queryBounded": {
|
|
42492
|
+
"default": 500,
|
|
42493
|
+
"max": 2500
|
|
42494
|
+
}
|
|
42495
|
+
},
|
|
42496
|
+
"resolution": null,
|
|
42497
|
+
"retry": {
|
|
42498
|
+
"preset": "retry-ffb3a9cb"
|
|
42499
|
+
},
|
|
42500
|
+
"errors": {
|
|
42501
|
+
"set": 4
|
|
42502
|
+
},
|
|
42503
|
+
"metadata": {
|
|
42504
|
+
"purpose": "Query UserDefinedFieldListItem records with a JSON filter.",
|
|
42505
|
+
"usage": "Server-side pagination: one call walks the vendor cursor internally (page 1 POSTs the QueryModel body with MaxRecords = the walk's internal page size (at most 500; the default POST path — `via: 'get'` issues a GET on page 1); later pages POST the SAME body — IncludeFields, MaxRecords and the preserved filter — to the absolute vendor cursor, rebased to the client base URL; the vendor honours IncludeFields on a continuation and ignores MaxRecords there, so a later page carries the vendor's own page size) until the limit is met or the cursor is null; 1000-page guard (hasMore stays true at the guard). queryAll is the unbounded raw walk — only when you need the ENTIRE set and accept a large payload; default to the bounded query op. noteChars: N (integer >= 1) is an opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose — the same set the server wraps): each capped value = the first N chars + the explicit marker … [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result (zero wire — response-side only). latest: N returns the N highest-id rows (id-descending): the vendor has no sort parameter — this is the only ordering channel, and a date window in `filter` narrows the cost; count-anchored — C ≤ 2500 → one count + a ≤6-page walk of the matching set, C > 2500 → count probes + an id-threshold window (≤64 probes; LATEST_THRESHOLD_UNRESOLVED on budget exhaustion), a blind count → a bounded walk with the blind-surface stamp (LATEST_WINDOW_INCOMPLETE on a truncated walk). Parent-scoped entity: the query stays global (filter with udfFieldId eq <parentId> where the parent is known). Each returned item carries `udfFieldId` (the parent link), so a global query result can drive the parent-scoped get. Explicit walk.maxRows independently sets the TOTAL returned-row cap (including export-sized walks); the ordinary limit is still validated in 1..2500 and only bounds the internal page size for this form. hasMore and truncated remain true at the page guard or while a cursor or unserved fetched rows remain. Self-resource prefixes are accepted in filter fields and includeFields; dotted UDF names are always refused before metadata or vendor requests, never rewritten to another tenant UDF.",
|
|
42506
|
+
"preferredWhen": "Default for filtered reads (the bounded query op). queryAll is the unbounded raw walk — only when you need the ENTIRE set and accept a large payload; default to the bounded query op. Prefer an includeFields subset over the full model (field names via operations.fieldCatalog). latest: N is the latest-N rows (id-descending) when the newest rows are the goal (the vendor has no sort — count-anchored, docs/API.md §4). Prefer a hand-listed includeFields for common narrow reads (removed the closed fieldsPreset presets — the v1 billing_join field list for billing_items.query, if you need it, is: companyID, ticketID, projectID, timeEntryID, contractServiceID, contractID, billingCodeID, expenseItemID, itemDate, quantity, rate, extendedPrice, totalAmount, nonBillable); noteChars: N caps the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose) to N chars each with the explicit … [+N chars truncated] marker (opt-in; the raw result when absent).",
|
|
42507
|
+
"related": [
|
|
42508
|
+
"user_defined_field_list_items.get"
|
|
42509
|
+
],
|
|
42510
|
+
"args": "args[0] is a params object: { filter?: FilterCondition[], limit?: total cap (default 500, max 2500; server-side pagination), latest?: number (1-2500 — the N highest-id rows; the vendor has no sort parameter, so this is a count-anchored mechanism — see docs/API.md §4; coexists with limit only when limit >= latest), noteChars?: number (integer >= 1 — opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker … [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result) maxRecords?: page size — raw SDK `queryAll`/`query` walks only (this bounded query ignores it; the invoke bag refuses it — pass limit), includeFields?: string[], fieldCheck?: boolean (default true — the pre-request field-name check on includeFields names and filter condition fields; false disables it — consumed by the invoke router, never sent to the vendor), via?: \"post\" | \"get\" (the wire method; the vendor GET has a 2048-char cap), acknowledgeUnscoped?: boolean (query verb only; a walk expected over 500 rows with no id scope in the filter is guarded — one pre-flight <resource>.count, and a count over 500 refuses with the typed SCOPE_REQUIRED before the walk; true walks the unscoped set anyway; a count that fails or is blind lets the walk run and the result’s scopeNote says so), walk?: { maxRows: positive integer (D6: the walk’s TOTAL row cap — serves at most maxRows rows in total; the page size stays min(500, limit), so one vendor page may fetch more rows than maxRows and the surplus is sliced off (fetched, not served); the result’s truncated flag — false only when the cursor is exhausted, true iff more rows exist past the cap (so an exact-multiple count with a live next page reports true); not combinable with latest) } }. Filter grammar: 13 operators: eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn (in/notIn: array or '1,2,3') + and/or grouping (no not-group). Field names in vendor API casing — get them via operations.fieldCatalog. Caps: 500 OR-conditions / 1 UDF / 8000 chars. By default the FULL vendor model is returned (all fields). To slim the payload for context savings pass includeFields with the exact vendor field names you need (discover them via operations.fieldCatalog); only those fields + id come back. The subset persists across the internal page walk.",
|
|
42511
|
+
"untrustedFields": [
|
|
42512
|
+
"valueForDisplay",
|
|
42513
|
+
"valueForExport"
|
|
42514
|
+
]
|
|
42515
|
+
},
|
|
42516
|
+
"compact": null,
|
|
42517
|
+
"status": "tested"
|
|
42518
|
+
},
|
|
42519
|
+
{
|
|
42520
|
+
"id": "user_defined_field_list_items.update",
|
|
42521
|
+
"resource": "user_defined_field_list_items",
|
|
42522
|
+
"udfCapable": false,
|
|
42523
|
+
"operation": "update",
|
|
42524
|
+
"kind": "primitive",
|
|
42525
|
+
"endpoint": "PUT|PATCH /V1.0/UserDefinedFields/{parentId}/ListItems",
|
|
42526
|
+
"effect": "write",
|
|
42527
|
+
"flags": [
|
|
42528
|
+
"idempotent"
|
|
42529
|
+
],
|
|
42530
|
+
"dryRun": true,
|
|
42531
|
+
"envelope": "OperationResultModel",
|
|
42532
|
+
"inputSchema": {
|
|
42533
|
+
"parentId": {
|
|
42534
|
+
"type": "string | number",
|
|
42535
|
+
"required": true,
|
|
42536
|
+
"description": "The parent record id (parent-scoped collection; number, or a canonical integer string)."
|
|
42537
|
+
},
|
|
42538
|
+
"id": {
|
|
42539
|
+
"type": "string | number",
|
|
42540
|
+
"required": true,
|
|
42541
|
+
"description": "The record id (number, or a canonical integer string — ids beyond 2^53 are supported via the string form)."
|
|
42542
|
+
},
|
|
42543
|
+
"data": {
|
|
42544
|
+
"type": "object",
|
|
42545
|
+
"required": true,
|
|
42546
|
+
"description": "The record payload (vendor model fields)."
|
|
42547
|
+
}
|
|
42548
|
+
},
|
|
42549
|
+
"inputSchemaStrict": true,
|
|
42550
|
+
"outputSchema": {
|
|
42551
|
+
"type": "OperationResultModel",
|
|
42552
|
+
"drops": []
|
|
42553
|
+
},
|
|
42554
|
+
"examples": [
|
|
42555
|
+
"await client.userDefinedFieldListItems.update('example-value', 'example-value', { name: 'example' }, { dryRun: true })"
|
|
42556
|
+
],
|
|
42557
|
+
"permissions": "unknown",
|
|
42558
|
+
"pagination": {
|
|
42559
|
+
"mode": "none"
|
|
42560
|
+
},
|
|
42561
|
+
"resolution": null,
|
|
42562
|
+
"retry": {
|
|
42563
|
+
"preset": "retry-85897a3a"
|
|
42564
|
+
},
|
|
42565
|
+
"errors": {
|
|
42566
|
+
"set": 1
|
|
42567
|
+
},
|
|
42568
|
+
"metadata": {
|
|
42569
|
+
"purpose": "Update a UDF list item.",
|
|
42570
|
+
"usage": "Issues PATCH on the collection (swagger documents put+patch there; the node strips the id from the path and the vendor keys the record by the id in the body). Stale check via lastModifiedDate where present. Parent-scoped: parentId + id. `valueForDisplay`/`valueForExport` stay required and unique; a list item that is the UDF's `defaultValue` has its `valueForDisplay` rename-locked (move the definition's `defaultValue` to another item first); toggling `isActive` is the only removal (no vendor delete).",
|
|
42571
|
+
"preferredWhen": "Preferred over create or delete when the record exists and only some fields change.",
|
|
42572
|
+
"related": [
|
|
42573
|
+
"user_defined_field_list_items.get"
|
|
42574
|
+
],
|
|
42575
|
+
"untrustedFields": [
|
|
42576
|
+
"valueForDisplay",
|
|
42577
|
+
"valueForExport"
|
|
42578
|
+
],
|
|
42579
|
+
"accountWide": true
|
|
42580
|
+
},
|
|
42581
|
+
"compact": null,
|
|
42582
|
+
"status": "tested"
|
|
42583
|
+
},
|
|
41562
42584
|
{
|
|
41563
42585
|
"id": "version_information.get",
|
|
41564
42586
|
"resource": "version_information",
|
|
@@ -41691,8 +42713,8 @@
|
|
|
41691
42713
|
]
|
|
41692
42714
|
},
|
|
41693
42715
|
"A": {
|
|
41694
|
-
"planHash": "
|
|
41695
|
-
"builtAt": "2026-11-
|
|
42716
|
+
"planHash": "6ea020dd5a389c0930923a23c1074b96e4280391b1d4fe6fca869e0effbf3a1a",
|
|
42717
|
+
"builtAt": "2026-11-11T11:15:40.016Z",
|
|
41696
42718
|
"records": [
|
|
41697
42719
|
{
|
|
41698
42720
|
"id": "companies.count",
|
|
@@ -81100,8 +82122,8 @@
|
|
|
81100
82122
|
]
|
|
81101
82123
|
},
|
|
81102
82124
|
"operations": {
|
|
81103
|
-
"planHash": "
|
|
81104
|
-
"builtAt": "2026-11-
|
|
82125
|
+
"planHash": "6ea020dd5a389c0930923a23c1074b96e4280391b1d4fe6fca869e0effbf3a1a",
|
|
82126
|
+
"builtAt": "2026-11-11T11:15:40.016Z",
|
|
81105
82127
|
"records": [
|
|
81106
82128
|
{
|
|
81107
82129
|
"id": "operations.aggregate",
|
|
@@ -82051,6 +83073,7 @@
|
|
|
82051
83073
|
"manufacturerServiceProvider",
|
|
82052
83074
|
"market",
|
|
82053
83075
|
"memo",
|
|
83076
|
+
"mergeVariableName",
|
|
82054
83077
|
"middleInitial",
|
|
82055
83078
|
"middleName",
|
|
82056
83079
|
"name",
|
|
@@ -82089,6 +83112,8 @@
|
|
|
82089
83112
|
"title",
|
|
82090
83113
|
"travelAvailabilityPct",
|
|
82091
83114
|
"userName",
|
|
83115
|
+
"valueForDisplay",
|
|
83116
|
+
"valueForExport",
|
|
82092
83117
|
"winReasonDetail"
|
|
82093
83118
|
]
|
|
82094
83119
|
},
|
|
@@ -82519,6 +83544,7 @@
|
|
|
82519
83544
|
"manufacturerServiceProvider",
|
|
82520
83545
|
"market",
|
|
82521
83546
|
"memo",
|
|
83547
|
+
"mergeVariableName",
|
|
82522
83548
|
"middleInitial",
|
|
82523
83549
|
"middleName",
|
|
82524
83550
|
"name",
|
|
@@ -82557,6 +83583,8 @@
|
|
|
82557
83583
|
"title",
|
|
82558
83584
|
"travelAvailabilityPct",
|
|
82559
83585
|
"userName",
|
|
83586
|
+
"valueForDisplay",
|
|
83587
|
+
"valueForExport",
|
|
82560
83588
|
"winReasonDetail"
|
|
82561
83589
|
]
|
|
82562
83590
|
},
|