node-autotask 0.70.0 → 0.72.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 +29 -0
- package/MCP_TOOL_CATALOG.json +515 -9
- package/README.md +1 -1
- package/capabilities.json +2108 -293
- package/dist/capabilities-data.js +2107 -292
- package/dist/capabilities.cjs +4 -4
- package/dist/capabilities.js +1 -1
- package/dist/{chunk-TYUTIZWB.js → chunk-A4IRIYZ5.js} +6 -2
- package/dist/{chunk-3RANR2RY.js → chunk-EGG2RGL5.js} +433 -8
- package/dist/{chunk-MN5VLBCI.js → chunk-F2TYZKJS.js} +2 -2
- package/dist/{chunk-YQX45JBG.cjs → chunk-HJVTA7SI.cjs} +34 -30
- package/dist/{chunk-SCFB5MF3.js → chunk-K33DPJFK.js} +3 -3
- package/dist/{chunk-YRRTE2NF.cjs → chunk-KVC5DZAP.cjs} +438 -13
- package/dist/{chunk-KAZE4WC7.cjs → chunk-SPME362B.cjs} +3 -3
- package/dist/{chunk-GVP2WW47.cjs → chunk-V5UGW6KZ.cjs} +177 -177
- package/dist/{index-COQEG55Q.d.cts → index-BXnhBnhN.d.cts} +248 -1
- package/dist/{index-COQEG55Q.d.ts → index-BXnhBnhN.d.ts} +248 -1
- package/dist/{index-CGW80Uzc.d.cts → index-CqsY5YHt.d.cts} +7 -2
- package/dist/{index-By9Zw2Oc.d.ts → index-DxfspQR1.d.ts} +7 -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 +51 -51
- package/dist/operations/index.d.cts +5 -5
- package/dist/operations/index.d.ts +5 -5
- package/dist/operations/index.js +2 -2
- package/dist/pool.cjs +12 -12
- 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 +86 -6
- package/docs/RELEASING.md +11 -3
- package/package.json +1 -1
package/capabilities.json
CHANGED
|
@@ -1,9 +1,9 @@
|
|
|
1
1
|
{
|
|
2
|
-
"generatedAt": "2026-11-
|
|
2
|
+
"generatedAt": "2026-11-18T13:26:09.242Z",
|
|
3
3
|
"groups": {
|
|
4
4
|
"B": {
|
|
5
|
-
"planHash": "
|
|
6
|
-
"builtAt": "2026-11-
|
|
5
|
+
"planHash": "79f3968f072705fbc7b479dba6863a27bde47deee7b85885eda8d019302f9c25",
|
|
6
|
+
"builtAt": "2026-11-18T13:26:09.223Z",
|
|
7
7
|
"records": [
|
|
8
8
|
{
|
|
9
9
|
"id": "appointments.count",
|
|
@@ -42786,9 +42786,386 @@
|
|
|
42786
42786
|
]
|
|
42787
42787
|
},
|
|
42788
42788
|
"A": {
|
|
42789
|
-
"planHash": "
|
|
42790
|
-
"builtAt": "2026-11-
|
|
42789
|
+
"planHash": "79f3968f072705fbc7b479dba6863a27bde47deee7b85885eda8d019302f9c25",
|
|
42790
|
+
"builtAt": "2026-11-18T13:26:09.224Z",
|
|
42791
42791
|
"records": [
|
|
42792
|
+
{
|
|
42793
|
+
"id": "attachment_info.count",
|
|
42794
|
+
"resource": "attachment_info",
|
|
42795
|
+
"udfCapable": false,
|
|
42796
|
+
"operation": "count",
|
|
42797
|
+
"kind": "primitive",
|
|
42798
|
+
"endpoint": "GET|POST /V1.0/AttachmentInfo/query/count",
|
|
42799
|
+
"effect": "read",
|
|
42800
|
+
"flags": [],
|
|
42801
|
+
"dryRun": false,
|
|
42802
|
+
"envelope": "QueryCountResultModel",
|
|
42803
|
+
"inputSchema": {
|
|
42804
|
+
"params": {
|
|
42805
|
+
"type": "object",
|
|
42806
|
+
"required": false,
|
|
42807
|
+
"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.",
|
|
42808
|
+
"properties": [
|
|
42809
|
+
{
|
|
42810
|
+
"name": "filter",
|
|
42811
|
+
"type": "FilterCondition[]",
|
|
42812
|
+
"optional": true
|
|
42813
|
+
},
|
|
42814
|
+
{
|
|
42815
|
+
"name": "fieldCheck",
|
|
42816
|
+
"type": "boolean",
|
|
42817
|
+
"optional": true
|
|
42818
|
+
}
|
|
42819
|
+
]
|
|
42820
|
+
}
|
|
42821
|
+
},
|
|
42822
|
+
"inputSchemaStrict": true,
|
|
42823
|
+
"outputSchema": {
|
|
42824
|
+
"type": "QueryCountResultModel",
|
|
42825
|
+
"drops": []
|
|
42826
|
+
},
|
|
42827
|
+
"examples": [
|
|
42828
|
+
"await client.attachmentInfo.count({ filter: [{ field: 'companyID', op: 'eq', value: 1 }] })"
|
|
42829
|
+
],
|
|
42830
|
+
"permissions": "unknown",
|
|
42831
|
+
"pagination": {
|
|
42832
|
+
"mode": "none"
|
|
42833
|
+
},
|
|
42834
|
+
"resolution": null,
|
|
42835
|
+
"retry": {
|
|
42836
|
+
"preset": "retry-ffb3a9cb"
|
|
42837
|
+
},
|
|
42838
|
+
"errors": {
|
|
42839
|
+
"set": 0
|
|
42840
|
+
},
|
|
42841
|
+
"metadata": {
|
|
42842
|
+
"purpose": "Count attachment information records matching a JSON filter.",
|
|
42843
|
+
"usage": "Unwraps queryCount; returns a plain number. Filter by companyID for company scope. fileSize is not queryable. Object-specific filters can include child attachments; an empty result is conditional on API-user permissions and visibility.",
|
|
42844
|
+
"preferredWhen": null,
|
|
42845
|
+
"related": [
|
|
42846
|
+
"attachment_info.query"
|
|
42847
|
+
],
|
|
42848
|
+
"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.",
|
|
42849
|
+
"untrustedFields": [
|
|
42850
|
+
"title"
|
|
42851
|
+
]
|
|
42852
|
+
},
|
|
42853
|
+
"compact": null,
|
|
42854
|
+
"status": "tested"
|
|
42855
|
+
},
|
|
42856
|
+
{
|
|
42857
|
+
"id": "attachment_info.get",
|
|
42858
|
+
"resource": "attachment_info",
|
|
42859
|
+
"udfCapable": false,
|
|
42860
|
+
"operation": "get",
|
|
42861
|
+
"kind": "primitive",
|
|
42862
|
+
"endpoint": "GET /V1.0/AttachmentInfo/{id}",
|
|
42863
|
+
"effect": "read",
|
|
42864
|
+
"flags": [],
|
|
42865
|
+
"dryRun": false,
|
|
42866
|
+
"envelope": "ItemQueryResultModel[AttachmentInfoModel,AttachmentInfo]",
|
|
42867
|
+
"inputSchema": {
|
|
42868
|
+
"id": {
|
|
42869
|
+
"type": "string | number",
|
|
42870
|
+
"required": true,
|
|
42871
|
+
"description": "The record id (number, or a canonical integer string — ids beyond 2^53 are supported via the string form)."
|
|
42872
|
+
},
|
|
42873
|
+
"opts": {
|
|
42874
|
+
"type": "object",
|
|
42875
|
+
"required": false,
|
|
42876
|
+
"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.",
|
|
42877
|
+
"properties": [
|
|
42878
|
+
{
|
|
42879
|
+
"name": "fresh",
|
|
42880
|
+
"type": "boolean",
|
|
42881
|
+
"optional": true
|
|
42882
|
+
}
|
|
42883
|
+
]
|
|
42884
|
+
}
|
|
42885
|
+
},
|
|
42886
|
+
"inputSchemaStrict": true,
|
|
42887
|
+
"outputSchema": {
|
|
42888
|
+
"type": "ItemQueryResultModel[AttachmentInfoModel,AttachmentInfo]",
|
|
42889
|
+
"drops": []
|
|
42890
|
+
},
|
|
42891
|
+
"examples": [
|
|
42892
|
+
"await client.attachmentInfo.get('example-value')"
|
|
42893
|
+
],
|
|
42894
|
+
"permissions": "unknown",
|
|
42895
|
+
"pagination": {
|
|
42896
|
+
"mode": "none"
|
|
42897
|
+
},
|
|
42898
|
+
"resolution": null,
|
|
42899
|
+
"retry": {
|
|
42900
|
+
"preset": "retry-ffb3a9cb"
|
|
42901
|
+
},
|
|
42902
|
+
"errors": {
|
|
42903
|
+
"set": 3
|
|
42904
|
+
},
|
|
42905
|
+
"metadata": {
|
|
42906
|
+
"purpose": "Get one AttachmentInfo by id.",
|
|
42907
|
+
"usage": "Returns item from the standard item envelope; item: null is a typed not-found.",
|
|
42908
|
+
"preferredWhen": "Use a known attachment id; query attachment_info with an object-specific filter to discover ids.",
|
|
42909
|
+
"related": [
|
|
42910
|
+
"attachment_info.query"
|
|
42911
|
+
],
|
|
42912
|
+
"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 attachment_info.query with includeFields.",
|
|
42913
|
+
"untrustedFields": [
|
|
42914
|
+
"title"
|
|
42915
|
+
]
|
|
42916
|
+
},
|
|
42917
|
+
"compact": null,
|
|
42918
|
+
"status": "tested"
|
|
42919
|
+
},
|
|
42920
|
+
{
|
|
42921
|
+
"id": "attachment_info.getEntityInfo",
|
|
42922
|
+
"resource": "attachment_info",
|
|
42923
|
+
"udfCapable": false,
|
|
42924
|
+
"operation": "getEntityInfo",
|
|
42925
|
+
"kind": "primitive",
|
|
42926
|
+
"endpoint": "GET /V1.0/AttachmentInfo/entityInformation",
|
|
42927
|
+
"effect": "read",
|
|
42928
|
+
"flags": [],
|
|
42929
|
+
"dryRun": false,
|
|
42930
|
+
"envelope": "EntityInformationResultModel",
|
|
42931
|
+
"inputSchema": {},
|
|
42932
|
+
"inputSchemaStrict": true,
|
|
42933
|
+
"outputSchema": {
|
|
42934
|
+
"type": "EntityInformationResultModel",
|
|
42935
|
+
"drops": []
|
|
42936
|
+
},
|
|
42937
|
+
"examples": [
|
|
42938
|
+
"await client.attachmentInfo.getEntityInfo()"
|
|
42939
|
+
],
|
|
42940
|
+
"permissions": "unknown",
|
|
42941
|
+
"pagination": {
|
|
42942
|
+
"mode": "none"
|
|
42943
|
+
},
|
|
42944
|
+
"resolution": null,
|
|
42945
|
+
"retry": {
|
|
42946
|
+
"preset": "retry-ffb3a9cb"
|
|
42947
|
+
},
|
|
42948
|
+
"errors": {
|
|
42949
|
+
"set": 0
|
|
42950
|
+
},
|
|
42951
|
+
"metadata": {
|
|
42952
|
+
"purpose": "Get the AttachmentInfo capability metadata (canCreate/canUpdate/hasUserDefinedFields/...).",
|
|
42953
|
+
"usage": "Unwraps info{}; drives client-side capability checks.",
|
|
42954
|
+
"preferredWhen": null,
|
|
42955
|
+
"related": [
|
|
42956
|
+
"attachment_info.getFieldInfo"
|
|
42957
|
+
],
|
|
42958
|
+
"untrustedFields": [
|
|
42959
|
+
"title"
|
|
42960
|
+
]
|
|
42961
|
+
},
|
|
42962
|
+
"compact": null,
|
|
42963
|
+
"status": "tested"
|
|
42964
|
+
},
|
|
42965
|
+
{
|
|
42966
|
+
"id": "attachment_info.getFieldInfo",
|
|
42967
|
+
"resource": "attachment_info",
|
|
42968
|
+
"udfCapable": false,
|
|
42969
|
+
"operation": "getFieldInfo",
|
|
42970
|
+
"kind": "primitive",
|
|
42971
|
+
"endpoint": "GET /V1.0/AttachmentInfo/entityInformation/fields",
|
|
42972
|
+
"effect": "read",
|
|
42973
|
+
"flags": [],
|
|
42974
|
+
"dryRun": false,
|
|
42975
|
+
"envelope": "FieldInformationResultModel",
|
|
42976
|
+
"inputSchema": {},
|
|
42977
|
+
"inputSchemaStrict": true,
|
|
42978
|
+
"outputSchema": {
|
|
42979
|
+
"type": "FieldInformationResultModel",
|
|
42980
|
+
"drops": []
|
|
42981
|
+
},
|
|
42982
|
+
"examples": [
|
|
42983
|
+
"await client.attachmentInfo.getFieldInfo()"
|
|
42984
|
+
],
|
|
42985
|
+
"permissions": "unknown",
|
|
42986
|
+
"pagination": {
|
|
42987
|
+
"mode": "none"
|
|
42988
|
+
},
|
|
42989
|
+
"resolution": null,
|
|
42990
|
+
"retry": {
|
|
42991
|
+
"preset": "retry-ffb3a9cb"
|
|
42992
|
+
},
|
|
42993
|
+
"errors": {
|
|
42994
|
+
"set": 0
|
|
42995
|
+
},
|
|
42996
|
+
"metadata": {
|
|
42997
|
+
"purpose": "Get the AttachmentInfo field catalog (types, picklists, required, maxLength) — the full raw field dump (the largest read of the info trio; compact discovery: operations.fieldCatalog).",
|
|
42998
|
+
"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.",
|
|
42999
|
+
"preferredWhen": null,
|
|
43000
|
+
"related": [
|
|
43001
|
+
"attachment_info.getEntityInfo",
|
|
43002
|
+
"attachment_info.getUdfInfo"
|
|
43003
|
+
],
|
|
43004
|
+
"untrustedFields": [
|
|
43005
|
+
"title"
|
|
43006
|
+
]
|
|
43007
|
+
},
|
|
43008
|
+
"compact": null,
|
|
43009
|
+
"status": "tested"
|
|
43010
|
+
},
|
|
43011
|
+
{
|
|
43012
|
+
"id": "attachment_info.getUdfInfo",
|
|
43013
|
+
"resource": "attachment_info",
|
|
43014
|
+
"udfCapable": false,
|
|
43015
|
+
"operation": "getUdfInfo",
|
|
43016
|
+
"kind": "primitive",
|
|
43017
|
+
"endpoint": "GET /V1.0/AttachmentInfo/entityInformation/userDefinedFields",
|
|
43018
|
+
"effect": "read",
|
|
43019
|
+
"flags": [],
|
|
43020
|
+
"dryRun": false,
|
|
43021
|
+
"envelope": "UserDefinedFieldInformationResultModel",
|
|
43022
|
+
"inputSchema": {},
|
|
43023
|
+
"inputSchemaStrict": true,
|
|
43024
|
+
"outputSchema": {
|
|
43025
|
+
"type": "UserDefinedFieldInformationResultModel",
|
|
43026
|
+
"drops": []
|
|
43027
|
+
},
|
|
43028
|
+
"examples": [
|
|
43029
|
+
"await client.attachmentInfo.getUdfInfo()"
|
|
43030
|
+
],
|
|
43031
|
+
"permissions": "unknown",
|
|
43032
|
+
"pagination": {
|
|
43033
|
+
"mode": "none"
|
|
43034
|
+
},
|
|
43035
|
+
"resolution": null,
|
|
43036
|
+
"retry": {
|
|
43037
|
+
"preset": "retry-ffb3a9cb"
|
|
43038
|
+
},
|
|
43039
|
+
"errors": {
|
|
43040
|
+
"set": 0
|
|
43041
|
+
},
|
|
43042
|
+
"metadata": {
|
|
43043
|
+
"purpose": "Get the AttachmentInfo user-defined-field catalog.",
|
|
43044
|
+
"usage": "Unwraps fields[]; only meaningful where the entity is UDF-capable. (entity is not UDF-capable; catalog is expected empty).",
|
|
43045
|
+
"preferredWhen": null,
|
|
43046
|
+
"related": [
|
|
43047
|
+
"attachment_info.getFieldInfo"
|
|
43048
|
+
],
|
|
43049
|
+
"untrustedFields": [
|
|
43050
|
+
"title"
|
|
43051
|
+
]
|
|
43052
|
+
},
|
|
43053
|
+
"compact": null,
|
|
43054
|
+
"status": "tested"
|
|
43055
|
+
},
|
|
43056
|
+
{
|
|
43057
|
+
"id": "attachment_info.query",
|
|
43058
|
+
"resource": "attachment_info",
|
|
43059
|
+
"udfCapable": false,
|
|
43060
|
+
"operation": "query",
|
|
43061
|
+
"kind": "primitive",
|
|
43062
|
+
"endpoint": "GET|POST /V1.0/AttachmentInfo/query",
|
|
43063
|
+
"effect": "read",
|
|
43064
|
+
"flags": [],
|
|
43065
|
+
"dryRun": false,
|
|
43066
|
+
"envelope": "QueryActionResult[<Model>,<Entity>]",
|
|
43067
|
+
"inputSchema": {
|
|
43068
|
+
"params": {
|
|
43069
|
+
"type": "object",
|
|
43070
|
+
"required": false,
|
|
43071
|
+
"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.",
|
|
43072
|
+
"properties": [
|
|
43073
|
+
{
|
|
43074
|
+
"name": "filter",
|
|
43075
|
+
"type": "FilterCondition[]",
|
|
43076
|
+
"optional": true
|
|
43077
|
+
},
|
|
43078
|
+
{
|
|
43079
|
+
"name": "limit",
|
|
43080
|
+
"type": "number",
|
|
43081
|
+
"optional": true,
|
|
43082
|
+
"default": 500
|
|
43083
|
+
},
|
|
43084
|
+
{
|
|
43085
|
+
"name": "latest",
|
|
43086
|
+
"type": "number",
|
|
43087
|
+
"optional": true
|
|
43088
|
+
},
|
|
43089
|
+
{
|
|
43090
|
+
"name": "noteChars",
|
|
43091
|
+
"type": "number",
|
|
43092
|
+
"optional": true
|
|
43093
|
+
},
|
|
43094
|
+
{
|
|
43095
|
+
"name": "includeFields",
|
|
43096
|
+
"type": "string[]",
|
|
43097
|
+
"optional": true
|
|
43098
|
+
},
|
|
43099
|
+
{
|
|
43100
|
+
"name": "fieldCheck",
|
|
43101
|
+
"type": "boolean",
|
|
43102
|
+
"optional": true,
|
|
43103
|
+
"default": true
|
|
43104
|
+
},
|
|
43105
|
+
{
|
|
43106
|
+
"name": "names",
|
|
43107
|
+
"type": "boolean",
|
|
43108
|
+
"optional": true
|
|
43109
|
+
},
|
|
43110
|
+
{
|
|
43111
|
+
"name": "via",
|
|
43112
|
+
"type": "\"post\" | \"get\"",
|
|
43113
|
+
"optional": true
|
|
43114
|
+
},
|
|
43115
|
+
{
|
|
43116
|
+
"name": "acknowledgeUnscoped",
|
|
43117
|
+
"type": "boolean",
|
|
43118
|
+
"optional": true
|
|
43119
|
+
},
|
|
43120
|
+
{
|
|
43121
|
+
"name": "walk",
|
|
43122
|
+
"type": "object",
|
|
43123
|
+
"optional": true
|
|
43124
|
+
}
|
|
43125
|
+
]
|
|
43126
|
+
}
|
|
43127
|
+
},
|
|
43128
|
+
"inputSchemaStrict": true,
|
|
43129
|
+
"outputSchema": {
|
|
43130
|
+
"type": "QueryActionResult[<Model>,<Entity>]",
|
|
43131
|
+
"drops": []
|
|
43132
|
+
},
|
|
43133
|
+
"examples": [
|
|
43134
|
+
"await client.attachmentInfo.query({ filter: [{ field: 'companyID', op: 'eq', value: 1 }], limit: 25 })"
|
|
43135
|
+
],
|
|
43136
|
+
"permissions": "unknown",
|
|
43137
|
+
"pagination": {
|
|
43138
|
+
"mode": "cursor",
|
|
43139
|
+
"vendorDefault": 10,
|
|
43140
|
+
"vendorMax": 500,
|
|
43141
|
+
"pageGuard": 1000,
|
|
43142
|
+
"queryBounded": {
|
|
43143
|
+
"default": 500,
|
|
43144
|
+
"max": 2500
|
|
43145
|
+
}
|
|
43146
|
+
},
|
|
43147
|
+
"resolution": null,
|
|
43148
|
+
"retry": {
|
|
43149
|
+
"preset": "retry-ffb3a9cb"
|
|
43150
|
+
},
|
|
43151
|
+
"errors": {
|
|
43152
|
+
"set": 4
|
|
43153
|
+
},
|
|
43154
|
+
"metadata": {
|
|
43155
|
+
"purpose": "Query AttachmentInfo records with a JSON filter.",
|
|
43156
|
+
"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. Filter by companyID for company scope. fileSize is not queryable. Object-specific filters can include child attachments; an empty result is conditional on API-user permissions and visibility.",
|
|
43157
|
+
"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).",
|
|
43158
|
+
"related": [
|
|
43159
|
+
"attachment_info.get"
|
|
43160
|
+
],
|
|
43161
|
+
"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.",
|
|
43162
|
+
"untrustedFields": [
|
|
43163
|
+
"title"
|
|
43164
|
+
]
|
|
43165
|
+
},
|
|
43166
|
+
"compact": null,
|
|
43167
|
+
"status": "tested"
|
|
43168
|
+
},
|
|
42792
43169
|
{
|
|
42793
43170
|
"id": "companies.count",
|
|
42794
43171
|
"resource": "companies",
|
|
@@ -45062,6 +45439,470 @@
|
|
|
45062
45439
|
"compact": null,
|
|
45063
45440
|
"status": "tested"
|
|
45064
45441
|
},
|
|
45442
|
+
{
|
|
45443
|
+
"id": "company_attachments.count",
|
|
45444
|
+
"resource": "company_attachments",
|
|
45445
|
+
"udfCapable": false,
|
|
45446
|
+
"operation": "count",
|
|
45447
|
+
"kind": "primitive",
|
|
45448
|
+
"endpoint": "GET|POST /V1.0/CompanyAttachments/query/count",
|
|
45449
|
+
"effect": "read",
|
|
45450
|
+
"flags": [],
|
|
45451
|
+
"dryRun": false,
|
|
45452
|
+
"envelope": "QueryCountResultModel",
|
|
45453
|
+
"inputSchema": {
|
|
45454
|
+
"params": {
|
|
45455
|
+
"type": "object",
|
|
45456
|
+
"required": false,
|
|
45457
|
+
"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.",
|
|
45458
|
+
"properties": [
|
|
45459
|
+
{
|
|
45460
|
+
"name": "filter",
|
|
45461
|
+
"type": "FilterCondition[]",
|
|
45462
|
+
"optional": true
|
|
45463
|
+
},
|
|
45464
|
+
{
|
|
45465
|
+
"name": "fieldCheck",
|
|
45466
|
+
"type": "boolean",
|
|
45467
|
+
"optional": true
|
|
45468
|
+
}
|
|
45469
|
+
]
|
|
45470
|
+
}
|
|
45471
|
+
},
|
|
45472
|
+
"inputSchemaStrict": true,
|
|
45473
|
+
"outputSchema": {
|
|
45474
|
+
"type": "QueryCountResultModel",
|
|
45475
|
+
"drops": []
|
|
45476
|
+
},
|
|
45477
|
+
"examples": [
|
|
45478
|
+
"await client.companyAttachments.count({ filter: [{ field: 'companyID', op: 'eq', value: 1 }] })"
|
|
45479
|
+
],
|
|
45480
|
+
"permissions": "unknown",
|
|
45481
|
+
"pagination": {
|
|
45482
|
+
"mode": "none"
|
|
45483
|
+
},
|
|
45484
|
+
"resolution": null,
|
|
45485
|
+
"retry": {
|
|
45486
|
+
"preset": "retry-ffb3a9cb"
|
|
45487
|
+
},
|
|
45488
|
+
"errors": {
|
|
45489
|
+
"set": 0
|
|
45490
|
+
},
|
|
45491
|
+
"metadata": {
|
|
45492
|
+
"purpose": "Count attachment records matching a JSON filter. (under a company)",
|
|
45493
|
+
"usage": "Unwraps queryCount; returns a plain number. Filter by companyID for company scope. creatorType, data and fileSize are not queryable. Object-specific filters can include child attachments; an empty result is conditional on API-user permissions and visibility.",
|
|
45494
|
+
"preferredWhen": null,
|
|
45495
|
+
"related": [
|
|
45496
|
+
"company_attachments.query"
|
|
45497
|
+
],
|
|
45498
|
+
"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.",
|
|
45499
|
+
"untrustedFields": [
|
|
45500
|
+
"title"
|
|
45501
|
+
]
|
|
45502
|
+
},
|
|
45503
|
+
"compact": null,
|
|
45504
|
+
"status": "tested"
|
|
45505
|
+
},
|
|
45506
|
+
{
|
|
45507
|
+
"id": "company_attachments.create",
|
|
45508
|
+
"resource": "company_attachments",
|
|
45509
|
+
"udfCapable": false,
|
|
45510
|
+
"operation": "create",
|
|
45511
|
+
"kind": "primitive",
|
|
45512
|
+
"endpoint": "POST /V1.0/Companies/{parentId}/Attachments",
|
|
45513
|
+
"effect": "write",
|
|
45514
|
+
"flags": [],
|
|
45515
|
+
"dryRun": true,
|
|
45516
|
+
"envelope": "OperationResultModel",
|
|
45517
|
+
"inputSchema": {
|
|
45518
|
+
"parentId": {
|
|
45519
|
+
"type": "string | number",
|
|
45520
|
+
"required": true,
|
|
45521
|
+
"description": "The parent record id (parent-scoped collection; number, or a canonical integer string)."
|
|
45522
|
+
},
|
|
45523
|
+
"data": {
|
|
45524
|
+
"type": "object",
|
|
45525
|
+
"required": true,
|
|
45526
|
+
"description": "The record payload (vendor model fields)."
|
|
45527
|
+
}
|
|
45528
|
+
},
|
|
45529
|
+
"inputSchemaStrict": true,
|
|
45530
|
+
"outputSchema": {
|
|
45531
|
+
"type": "OperationResultModel",
|
|
45532
|
+
"drops": []
|
|
45533
|
+
},
|
|
45534
|
+
"examples": [
|
|
45535
|
+
"await client.companyAttachments.create(1, { attachmentType: 'FILE_ATTACHMENT', fullPath: 'note.txt', title: 'Supporting note', publish: 1, data: 'bm90ZQ==' }, { dryRun: true })"
|
|
45536
|
+
],
|
|
45537
|
+
"permissions": "unknown",
|
|
45538
|
+
"pagination": {
|
|
45539
|
+
"mode": "none"
|
|
45540
|
+
},
|
|
45541
|
+
"resolution": null,
|
|
45542
|
+
"retry": {
|
|
45543
|
+
"preset": "retry-c5657094"
|
|
45544
|
+
},
|
|
45545
|
+
"errors": {
|
|
45546
|
+
"set": 1
|
|
45547
|
+
},
|
|
45548
|
+
"metadata": {
|
|
45549
|
+
"purpose": "Create an attachment. (under a company)",
|
|
45550
|
+
"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. FILE_ATTACHMENT requires base64 data; use current attachmentType/publish metadata and vendor file limits. ParentId addresses the Companies record. Permission and impersonation restrictions apply.",
|
|
45551
|
+
"preferredWhen": "Add a new attachment; existing attachments cannot be updated. Replace through separately governed delete and create actions.",
|
|
45552
|
+
"related": [
|
|
45553
|
+
"company_attachments.get"
|
|
45554
|
+
],
|
|
45555
|
+
"untrustedFields": [
|
|
45556
|
+
"title"
|
|
45557
|
+
],
|
|
45558
|
+
"createRequirements": {
|
|
45559
|
+
"requiresByValue": [
|
|
45560
|
+
{
|
|
45561
|
+
"field": "attachmentType",
|
|
45562
|
+
"value": "FILE_ATTACHMENT",
|
|
45563
|
+
"requires": {
|
|
45564
|
+
"allOf": [
|
|
45565
|
+
"data"
|
|
45566
|
+
]
|
|
45567
|
+
}
|
|
45568
|
+
}
|
|
45569
|
+
]
|
|
45570
|
+
}
|
|
45571
|
+
},
|
|
45572
|
+
"compact": null,
|
|
45573
|
+
"status": "tested"
|
|
45574
|
+
},
|
|
45575
|
+
{
|
|
45576
|
+
"id": "company_attachments.delete",
|
|
45577
|
+
"resource": "company_attachments",
|
|
45578
|
+
"udfCapable": false,
|
|
45579
|
+
"operation": "delete",
|
|
45580
|
+
"kind": "primitive",
|
|
45581
|
+
"endpoint": "DELETE /V1.0/Companies/{parentId}/Attachments/{id}",
|
|
45582
|
+
"effect": "destructive",
|
|
45583
|
+
"flags": [
|
|
45584
|
+
"idempotent",
|
|
45585
|
+
"requiresApproval"
|
|
45586
|
+
],
|
|
45587
|
+
"dryRun": true,
|
|
45588
|
+
"envelope": "OperationResultModel (attachment entities: the deleted attachment model is returned, not OperationResultModel)",
|
|
45589
|
+
"inputSchema": {
|
|
45590
|
+
"parentId": {
|
|
45591
|
+
"type": "string | number",
|
|
45592
|
+
"required": true,
|
|
45593
|
+
"description": "The parent record id (parent-scoped collection; number, or a canonical integer string)."
|
|
45594
|
+
},
|
|
45595
|
+
"id": {
|
|
45596
|
+
"type": "string | number",
|
|
45597
|
+
"required": true,
|
|
45598
|
+
"description": "The record id (number, or a canonical integer string — ids beyond 2^53 are supported via the string form)."
|
|
45599
|
+
}
|
|
45600
|
+
},
|
|
45601
|
+
"inputSchemaStrict": true,
|
|
45602
|
+
"outputSchema": {
|
|
45603
|
+
"type": "OperationResultModel (attachment entities: the deleted attachment model is returned, not OperationResultModel)",
|
|
45604
|
+
"drops": []
|
|
45605
|
+
},
|
|
45606
|
+
"examples": [
|
|
45607
|
+
"await invoke(client, 'company_attachments.delete', ['example-value', 'example-value'], { dryRun: false, confirm: 'company_attachments.delete' })"
|
|
45608
|
+
],
|
|
45609
|
+
"permissions": "unknown",
|
|
45610
|
+
"pagination": {
|
|
45611
|
+
"mode": "none"
|
|
45612
|
+
},
|
|
45613
|
+
"resolution": null,
|
|
45614
|
+
"retry": {
|
|
45615
|
+
"preset": "retry-1849870d"
|
|
45616
|
+
},
|
|
45617
|
+
"errors": {
|
|
45618
|
+
"set": 2
|
|
45619
|
+
},
|
|
45620
|
+
"metadata": {
|
|
45621
|
+
"purpose": "Delete an attachment. (under a company)",
|
|
45622
|
+
"usage": "Irreversible; dry-run validates the target id first. Parent-scoped: parentId + id.",
|
|
45623
|
+
"preferredWhen": null,
|
|
45624
|
+
"related": [
|
|
45625
|
+
"company_attachments.get"
|
|
45626
|
+
],
|
|
45627
|
+
"untrustedFields": [
|
|
45628
|
+
"title"
|
|
45629
|
+
]
|
|
45630
|
+
},
|
|
45631
|
+
"compact": null,
|
|
45632
|
+
"status": "tested"
|
|
45633
|
+
},
|
|
45634
|
+
{
|
|
45635
|
+
"id": "company_attachments.get",
|
|
45636
|
+
"resource": "company_attachments",
|
|
45637
|
+
"udfCapable": false,
|
|
45638
|
+
"operation": "get",
|
|
45639
|
+
"kind": "primitive",
|
|
45640
|
+
"endpoint": "GET /V1.0/Companies/{parentId}/Attachments/{id}",
|
|
45641
|
+
"effect": "read",
|
|
45642
|
+
"flags": [],
|
|
45643
|
+
"dryRun": false,
|
|
45644
|
+
"envelope": "CompanyAttachmentModel",
|
|
45645
|
+
"inputSchema": {
|
|
45646
|
+
"parentId": {
|
|
45647
|
+
"type": "string | number",
|
|
45648
|
+
"required": true,
|
|
45649
|
+
"description": "The parent record id (parent-scoped collection; number, or a canonical integer string)."
|
|
45650
|
+
},
|
|
45651
|
+
"id": {
|
|
45652
|
+
"type": "string | number",
|
|
45653
|
+
"required": true,
|
|
45654
|
+
"description": "The record id (number, or a canonical integer string — ids beyond 2^53 are supported via the string form)."
|
|
45655
|
+
},
|
|
45656
|
+
"opts": {
|
|
45657
|
+
"type": "object",
|
|
45658
|
+
"required": false,
|
|
45659
|
+
"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.",
|
|
45660
|
+
"properties": [
|
|
45661
|
+
{
|
|
45662
|
+
"name": "fresh",
|
|
45663
|
+
"type": "boolean",
|
|
45664
|
+
"optional": true
|
|
45665
|
+
}
|
|
45666
|
+
]
|
|
45667
|
+
}
|
|
45668
|
+
},
|
|
45669
|
+
"inputSchemaStrict": true,
|
|
45670
|
+
"outputSchema": {
|
|
45671
|
+
"type": "CompanyAttachmentModel",
|
|
45672
|
+
"drops": []
|
|
45673
|
+
},
|
|
45674
|
+
"examples": [
|
|
45675
|
+
"await client.companyAttachments.get('example-value', 'example-value')"
|
|
45676
|
+
],
|
|
45677
|
+
"permissions": "unknown",
|
|
45678
|
+
"pagination": {
|
|
45679
|
+
"mode": "none"
|
|
45680
|
+
},
|
|
45681
|
+
"resolution": null,
|
|
45682
|
+
"retry": {
|
|
45683
|
+
"preset": "retry-ffb3a9cb"
|
|
45684
|
+
},
|
|
45685
|
+
"errors": {
|
|
45686
|
+
"set": 3
|
|
45687
|
+
},
|
|
45688
|
+
"metadata": {
|
|
45689
|
+
"purpose": "Get one CompanyAttachment by id.",
|
|
45690
|
+
"usage": "Returns the attachment model directly; item: null or an empty model is a typed not-found. Parent-scoped: parentId is the company id, followed by the attachment id.",
|
|
45691
|
+
"preferredWhen": "Use a known attachment id; query the scoped collection to discover ids.",
|
|
45692
|
+
"related": [
|
|
45693
|
+
"company_attachments.query"
|
|
45694
|
+
],
|
|
45695
|
+
"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 a company_attachments.query with includeFields.",
|
|
45696
|
+
"untrustedFields": [
|
|
45697
|
+
"title"
|
|
45698
|
+
]
|
|
45699
|
+
},
|
|
45700
|
+
"compact": null,
|
|
45701
|
+
"status": "tested"
|
|
45702
|
+
},
|
|
45703
|
+
{
|
|
45704
|
+
"id": "company_attachments.getEntityInfo",
|
|
45705
|
+
"resource": "company_attachments",
|
|
45706
|
+
"udfCapable": false,
|
|
45707
|
+
"operation": "getEntityInfo",
|
|
45708
|
+
"kind": "primitive",
|
|
45709
|
+
"endpoint": "GET /V1.0/CompanyAttachments/entityInformation",
|
|
45710
|
+
"effect": "read",
|
|
45711
|
+
"flags": [],
|
|
45712
|
+
"dryRun": false,
|
|
45713
|
+
"envelope": "EntityInformationResultModel",
|
|
45714
|
+
"inputSchema": {},
|
|
45715
|
+
"inputSchemaStrict": true,
|
|
45716
|
+
"outputSchema": {
|
|
45717
|
+
"type": "EntityInformationResultModel",
|
|
45718
|
+
"drops": []
|
|
45719
|
+
},
|
|
45720
|
+
"examples": [
|
|
45721
|
+
"await client.companyAttachments.getEntityInfo()"
|
|
45722
|
+
],
|
|
45723
|
+
"permissions": "unknown",
|
|
45724
|
+
"pagination": {
|
|
45725
|
+
"mode": "none"
|
|
45726
|
+
},
|
|
45727
|
+
"resolution": null,
|
|
45728
|
+
"retry": {
|
|
45729
|
+
"preset": "retry-ffb3a9cb"
|
|
45730
|
+
},
|
|
45731
|
+
"errors": {
|
|
45732
|
+
"set": 0
|
|
45733
|
+
},
|
|
45734
|
+
"metadata": {
|
|
45735
|
+
"purpose": "Get the CompanyAttachment capability metadata (canCreate/canUpdate/hasUserDefinedFields/...).",
|
|
45736
|
+
"usage": "Unwraps info{}; drives client-side capability checks.",
|
|
45737
|
+
"preferredWhen": null,
|
|
45738
|
+
"related": [
|
|
45739
|
+
"company_attachments.getFieldInfo"
|
|
45740
|
+
],
|
|
45741
|
+
"untrustedFields": [
|
|
45742
|
+
"title"
|
|
45743
|
+
]
|
|
45744
|
+
},
|
|
45745
|
+
"compact": null,
|
|
45746
|
+
"status": "tested"
|
|
45747
|
+
},
|
|
45748
|
+
{
|
|
45749
|
+
"id": "company_attachments.getFieldInfo",
|
|
45750
|
+
"resource": "company_attachments",
|
|
45751
|
+
"udfCapable": false,
|
|
45752
|
+
"operation": "getFieldInfo",
|
|
45753
|
+
"kind": "primitive",
|
|
45754
|
+
"endpoint": "GET /V1.0/CompanyAttachments/entityInformation/fields",
|
|
45755
|
+
"effect": "read",
|
|
45756
|
+
"flags": [],
|
|
45757
|
+
"dryRun": false,
|
|
45758
|
+
"envelope": "FieldInformationResultModel",
|
|
45759
|
+
"inputSchema": {},
|
|
45760
|
+
"inputSchemaStrict": true,
|
|
45761
|
+
"outputSchema": {
|
|
45762
|
+
"type": "FieldInformationResultModel",
|
|
45763
|
+
"drops": []
|
|
45764
|
+
},
|
|
45765
|
+
"examples": [
|
|
45766
|
+
"await client.companyAttachments.getFieldInfo()"
|
|
45767
|
+
],
|
|
45768
|
+
"permissions": "unknown",
|
|
45769
|
+
"pagination": {
|
|
45770
|
+
"mode": "none"
|
|
45771
|
+
},
|
|
45772
|
+
"resolution": null,
|
|
45773
|
+
"retry": {
|
|
45774
|
+
"preset": "retry-ffb3a9cb"
|
|
45775
|
+
},
|
|
45776
|
+
"errors": {
|
|
45777
|
+
"set": 0
|
|
45778
|
+
},
|
|
45779
|
+
"metadata": {
|
|
45780
|
+
"purpose": "Get the CompanyAttachment field catalog (types, picklists, required, maxLength) — the full raw field dump (the largest read of the info trio; compact discovery: operations.fieldCatalog).",
|
|
45781
|
+
"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.",
|
|
45782
|
+
"preferredWhen": null,
|
|
45783
|
+
"related": [
|
|
45784
|
+
"company_attachments.getEntityInfo"
|
|
45785
|
+
],
|
|
45786
|
+
"untrustedFields": [
|
|
45787
|
+
"title"
|
|
45788
|
+
]
|
|
45789
|
+
},
|
|
45790
|
+
"compact": null,
|
|
45791
|
+
"status": "tested"
|
|
45792
|
+
},
|
|
45793
|
+
{
|
|
45794
|
+
"id": "company_attachments.query",
|
|
45795
|
+
"resource": "company_attachments",
|
|
45796
|
+
"udfCapable": false,
|
|
45797
|
+
"operation": "query",
|
|
45798
|
+
"kind": "primitive",
|
|
45799
|
+
"endpoint": "GET|POST /V1.0/CompanyAttachments/query",
|
|
45800
|
+
"effect": "read",
|
|
45801
|
+
"flags": [],
|
|
45802
|
+
"dryRun": false,
|
|
45803
|
+
"envelope": "QueryActionResult[<Model>,<Entity>]",
|
|
45804
|
+
"inputSchema": {
|
|
45805
|
+
"params": {
|
|
45806
|
+
"type": "object",
|
|
45807
|
+
"required": false,
|
|
45808
|
+
"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.",
|
|
45809
|
+
"properties": [
|
|
45810
|
+
{
|
|
45811
|
+
"name": "filter",
|
|
45812
|
+
"type": "FilterCondition[]",
|
|
45813
|
+
"optional": true
|
|
45814
|
+
},
|
|
45815
|
+
{
|
|
45816
|
+
"name": "limit",
|
|
45817
|
+
"type": "number",
|
|
45818
|
+
"optional": true,
|
|
45819
|
+
"default": 500
|
|
45820
|
+
},
|
|
45821
|
+
{
|
|
45822
|
+
"name": "latest",
|
|
45823
|
+
"type": "number",
|
|
45824
|
+
"optional": true
|
|
45825
|
+
},
|
|
45826
|
+
{
|
|
45827
|
+
"name": "noteChars",
|
|
45828
|
+
"type": "number",
|
|
45829
|
+
"optional": true
|
|
45830
|
+
},
|
|
45831
|
+
{
|
|
45832
|
+
"name": "includeFields",
|
|
45833
|
+
"type": "string[]",
|
|
45834
|
+
"optional": true
|
|
45835
|
+
},
|
|
45836
|
+
{
|
|
45837
|
+
"name": "fieldCheck",
|
|
45838
|
+
"type": "boolean",
|
|
45839
|
+
"optional": true,
|
|
45840
|
+
"default": true
|
|
45841
|
+
},
|
|
45842
|
+
{
|
|
45843
|
+
"name": "names",
|
|
45844
|
+
"type": "boolean",
|
|
45845
|
+
"optional": true
|
|
45846
|
+
},
|
|
45847
|
+
{
|
|
45848
|
+
"name": "via",
|
|
45849
|
+
"type": "\"post\" | \"get\"",
|
|
45850
|
+
"optional": true
|
|
45851
|
+
},
|
|
45852
|
+
{
|
|
45853
|
+
"name": "acknowledgeUnscoped",
|
|
45854
|
+
"type": "boolean",
|
|
45855
|
+
"optional": true
|
|
45856
|
+
},
|
|
45857
|
+
{
|
|
45858
|
+
"name": "walk",
|
|
45859
|
+
"type": "object",
|
|
45860
|
+
"optional": true
|
|
45861
|
+
}
|
|
45862
|
+
]
|
|
45863
|
+
}
|
|
45864
|
+
},
|
|
45865
|
+
"inputSchemaStrict": true,
|
|
45866
|
+
"outputSchema": {
|
|
45867
|
+
"type": "QueryActionResult[<Model>,<Entity>]",
|
|
45868
|
+
"drops": []
|
|
45869
|
+
},
|
|
45870
|
+
"examples": [
|
|
45871
|
+
"await client.companyAttachments.query({ filter: [{ field: 'companyID', op: 'eq', value: 1 }], limit: 25 })"
|
|
45872
|
+
],
|
|
45873
|
+
"permissions": "unknown",
|
|
45874
|
+
"pagination": {
|
|
45875
|
+
"mode": "cursor",
|
|
45876
|
+
"vendorDefault": 10,
|
|
45877
|
+
"vendorMax": 500,
|
|
45878
|
+
"pageGuard": 1000,
|
|
45879
|
+
"queryBounded": {
|
|
45880
|
+
"default": 500,
|
|
45881
|
+
"max": 2500
|
|
45882
|
+
}
|
|
45883
|
+
},
|
|
45884
|
+
"resolution": null,
|
|
45885
|
+
"retry": {
|
|
45886
|
+
"preset": "retry-ffb3a9cb"
|
|
45887
|
+
},
|
|
45888
|
+
"errors": {
|
|
45889
|
+
"set": 4
|
|
45890
|
+
},
|
|
45891
|
+
"metadata": {
|
|
45892
|
+
"purpose": "Query CompanyAttachment records with a JSON filter.",
|
|
45893
|
+
"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 companyID eq <parentId> where the parent is known). 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. Filter by companyID for company scope. creatorType, data and fileSize are not queryable. Object-specific filters can include child attachments; an empty result is conditional on API-user permissions and visibility. The Swagger query response names an attachment model, while this collection uses the existing SDK attachment query contract { items, pageDetails }; a bare-model response is rejected as INVALID_RESPONSE rather than guessed into a collection.",
|
|
45894
|
+
"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).",
|
|
45895
|
+
"related": [
|
|
45896
|
+
"company_attachments.get"
|
|
45897
|
+
],
|
|
45898
|
+
"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.",
|
|
45899
|
+
"untrustedFields": [
|
|
45900
|
+
"title"
|
|
45901
|
+
]
|
|
45902
|
+
},
|
|
45903
|
+
"compact": null,
|
|
45904
|
+
"status": "tested"
|
|
45905
|
+
},
|
|
45065
45906
|
{
|
|
45066
45907
|
"id": "company_locations.count",
|
|
45067
45908
|
"resource": "company_locations",
|
|
@@ -45281,11 +46122,727 @@
|
|
|
45281
46122
|
},
|
|
45282
46123
|
"inputSchemaStrict": true,
|
|
45283
46124
|
"outputSchema": {
|
|
45284
|
-
"type": "ItemQueryResultModel[CompanyLocationModel,AccountPhysicalLocation]",
|
|
46125
|
+
"type": "ItemQueryResultModel[CompanyLocationModel,AccountPhysicalLocation]",
|
|
46126
|
+
"drops": []
|
|
46127
|
+
},
|
|
46128
|
+
"examples": [
|
|
46129
|
+
"await client.companyLocations.get('example-value', 'example-value')"
|
|
46130
|
+
],
|
|
46131
|
+
"permissions": "unknown",
|
|
46132
|
+
"pagination": {
|
|
46133
|
+
"mode": "none"
|
|
46134
|
+
},
|
|
46135
|
+
"resolution": null,
|
|
46136
|
+
"retry": {
|
|
46137
|
+
"preset": "retry-ffb3a9cb"
|
|
46138
|
+
},
|
|
46139
|
+
"errors": {
|
|
46140
|
+
"set": 3
|
|
46141
|
+
},
|
|
46142
|
+
"metadata": {
|
|
46143
|
+
"purpose": "Get one CompanyLocation by id.",
|
|
46144
|
+
"usage": "item: null on the 200 body maps to NotFoundError (vendor not-found signal). Parent-scoped: parentId + id.",
|
|
46145
|
+
"preferredWhen": "Preferred when the numeric id is already known; company_locations.resolve is for a field value.",
|
|
46146
|
+
"related": [
|
|
46147
|
+
"company_locations.resolve"
|
|
46148
|
+
],
|
|
46149
|
+
"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 company_locations.search (compact summary) or a company_locations.query with includeFields.",
|
|
46150
|
+
"untrustedFields": [
|
|
46151
|
+
"description",
|
|
46152
|
+
"name"
|
|
46153
|
+
]
|
|
46154
|
+
},
|
|
46155
|
+
"compact": null,
|
|
46156
|
+
"status": "tested"
|
|
46157
|
+
},
|
|
46158
|
+
{
|
|
46159
|
+
"id": "company_locations.getEntityInfo",
|
|
46160
|
+
"resource": "company_locations",
|
|
46161
|
+
"udfCapable": false,
|
|
46162
|
+
"operation": "getEntityInfo",
|
|
46163
|
+
"kind": "primitive",
|
|
46164
|
+
"endpoint": "GET /V1.0/CompanyLocations/entityInformation",
|
|
46165
|
+
"effect": "read",
|
|
46166
|
+
"flags": [],
|
|
46167
|
+
"dryRun": false,
|
|
46168
|
+
"envelope": "EntityInformationResultModel",
|
|
46169
|
+
"inputSchema": {},
|
|
46170
|
+
"inputSchemaStrict": true,
|
|
46171
|
+
"outputSchema": {
|
|
46172
|
+
"type": "EntityInformationResultModel",
|
|
46173
|
+
"drops": []
|
|
46174
|
+
},
|
|
46175
|
+
"examples": [
|
|
46176
|
+
"await client.companyLocations.getEntityInfo()"
|
|
46177
|
+
],
|
|
46178
|
+
"permissions": "unknown",
|
|
46179
|
+
"pagination": {
|
|
46180
|
+
"mode": "none"
|
|
46181
|
+
},
|
|
46182
|
+
"resolution": null,
|
|
46183
|
+
"retry": {
|
|
46184
|
+
"preset": "retry-ffb3a9cb"
|
|
46185
|
+
},
|
|
46186
|
+
"errors": {
|
|
46187
|
+
"set": 0
|
|
46188
|
+
},
|
|
46189
|
+
"metadata": {
|
|
46190
|
+
"purpose": "Get the CompanyLocation capability metadata (canCreate/canUpdate/hasUserDefinedFields/...).",
|
|
46191
|
+
"usage": "Unwraps info{}; drives client-side capability checks.",
|
|
46192
|
+
"preferredWhen": null,
|
|
46193
|
+
"related": [
|
|
46194
|
+
"company_locations.getFieldInfo"
|
|
46195
|
+
],
|
|
46196
|
+
"untrustedFields": [
|
|
46197
|
+
"description",
|
|
46198
|
+
"name"
|
|
46199
|
+
]
|
|
46200
|
+
},
|
|
46201
|
+
"compact": null,
|
|
46202
|
+
"status": "tested"
|
|
46203
|
+
},
|
|
46204
|
+
{
|
|
46205
|
+
"id": "company_locations.getFieldInfo",
|
|
46206
|
+
"resource": "company_locations",
|
|
46207
|
+
"udfCapable": false,
|
|
46208
|
+
"operation": "getFieldInfo",
|
|
46209
|
+
"kind": "primitive",
|
|
46210
|
+
"endpoint": "GET /V1.0/CompanyLocations/entityInformation/fields",
|
|
46211
|
+
"effect": "read",
|
|
46212
|
+
"flags": [],
|
|
46213
|
+
"dryRun": false,
|
|
46214
|
+
"envelope": "FieldInformationResultModel",
|
|
46215
|
+
"inputSchema": {},
|
|
46216
|
+
"inputSchemaStrict": true,
|
|
46217
|
+
"outputSchema": {
|
|
46218
|
+
"type": "FieldInformationResultModel",
|
|
46219
|
+
"drops": []
|
|
46220
|
+
},
|
|
46221
|
+
"examples": [
|
|
46222
|
+
"await client.companyLocations.getFieldInfo()"
|
|
46223
|
+
],
|
|
46224
|
+
"permissions": "unknown",
|
|
46225
|
+
"pagination": {
|
|
46226
|
+
"mode": "none"
|
|
46227
|
+
},
|
|
46228
|
+
"resolution": null,
|
|
46229
|
+
"retry": {
|
|
46230
|
+
"preset": "retry-ffb3a9cb"
|
|
46231
|
+
},
|
|
46232
|
+
"errors": {
|
|
46233
|
+
"set": 0
|
|
46234
|
+
},
|
|
46235
|
+
"metadata": {
|
|
46236
|
+
"purpose": "Get the CompanyLocation field catalog (types, picklists, required, maxLength) — the full raw field dump (the largest read of the info trio; compact discovery: operations.fieldCatalog).",
|
|
46237
|
+
"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.",
|
|
46238
|
+
"preferredWhen": null,
|
|
46239
|
+
"related": [
|
|
46240
|
+
"company_locations.getEntityInfo",
|
|
46241
|
+
"company_locations.getUdfInfo"
|
|
46242
|
+
],
|
|
46243
|
+
"untrustedFields": [
|
|
46244
|
+
"description",
|
|
46245
|
+
"name"
|
|
46246
|
+
]
|
|
46247
|
+
},
|
|
46248
|
+
"compact": null,
|
|
46249
|
+
"status": "tested"
|
|
46250
|
+
},
|
|
46251
|
+
{
|
|
46252
|
+
"id": "company_locations.getUdfInfo",
|
|
46253
|
+
"resource": "company_locations",
|
|
46254
|
+
"udfCapable": false,
|
|
46255
|
+
"operation": "getUdfInfo",
|
|
46256
|
+
"kind": "primitive",
|
|
46257
|
+
"endpoint": "GET /V1.0/CompanyLocations/entityInformation/userDefinedFields",
|
|
46258
|
+
"effect": "read",
|
|
46259
|
+
"flags": [],
|
|
46260
|
+
"dryRun": false,
|
|
46261
|
+
"envelope": "UserDefinedFieldInformationResultModel",
|
|
46262
|
+
"inputSchema": {},
|
|
46263
|
+
"inputSchemaStrict": true,
|
|
46264
|
+
"outputSchema": {
|
|
46265
|
+
"type": "UserDefinedFieldInformationResultModel",
|
|
46266
|
+
"drops": []
|
|
46267
|
+
},
|
|
46268
|
+
"examples": [
|
|
46269
|
+
"await client.companyLocations.getUdfInfo()"
|
|
46270
|
+
],
|
|
46271
|
+
"permissions": "unknown",
|
|
46272
|
+
"pagination": {
|
|
46273
|
+
"mode": "none"
|
|
46274
|
+
},
|
|
46275
|
+
"resolution": null,
|
|
46276
|
+
"retry": {
|
|
46277
|
+
"preset": "retry-ffb3a9cb"
|
|
46278
|
+
},
|
|
46279
|
+
"errors": {
|
|
46280
|
+
"set": 0
|
|
46281
|
+
},
|
|
46282
|
+
"metadata": {
|
|
46283
|
+
"purpose": "Get the CompanyLocation user-defined-field catalog.",
|
|
46284
|
+
"usage": "Unwraps fields[]; only meaningful where the entity is UDF-capable. (entity is not UDF-capable; catalog is expected empty).",
|
|
46285
|
+
"preferredWhen": null,
|
|
46286
|
+
"related": [
|
|
46287
|
+
"company_locations.getFieldInfo"
|
|
46288
|
+
],
|
|
46289
|
+
"untrustedFields": [
|
|
46290
|
+
"description",
|
|
46291
|
+
"name"
|
|
46292
|
+
]
|
|
46293
|
+
},
|
|
46294
|
+
"compact": null,
|
|
46295
|
+
"status": "tested"
|
|
46296
|
+
},
|
|
46297
|
+
{
|
|
46298
|
+
"id": "company_locations.query",
|
|
46299
|
+
"resource": "company_locations",
|
|
46300
|
+
"udfCapable": false,
|
|
46301
|
+
"operation": "query",
|
|
46302
|
+
"kind": "primitive",
|
|
46303
|
+
"endpoint": "GET|POST /V1.0/CompanyLocations/query",
|
|
46304
|
+
"effect": "read",
|
|
46305
|
+
"flags": [],
|
|
46306
|
+
"dryRun": false,
|
|
46307
|
+
"envelope": "QueryActionResult[<Model>,<Entity>]",
|
|
46308
|
+
"inputSchema": {
|
|
46309
|
+
"params": {
|
|
46310
|
+
"type": "object",
|
|
46311
|
+
"required": false,
|
|
46312
|
+
"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.",
|
|
46313
|
+
"properties": [
|
|
46314
|
+
{
|
|
46315
|
+
"name": "filter",
|
|
46316
|
+
"type": "FilterCondition[]",
|
|
46317
|
+
"optional": true
|
|
46318
|
+
},
|
|
46319
|
+
{
|
|
46320
|
+
"name": "limit",
|
|
46321
|
+
"type": "number",
|
|
46322
|
+
"optional": true,
|
|
46323
|
+
"default": 500
|
|
46324
|
+
},
|
|
46325
|
+
{
|
|
46326
|
+
"name": "latest",
|
|
46327
|
+
"type": "number",
|
|
46328
|
+
"optional": true
|
|
46329
|
+
},
|
|
46330
|
+
{
|
|
46331
|
+
"name": "noteChars",
|
|
46332
|
+
"type": "number",
|
|
46333
|
+
"optional": true
|
|
46334
|
+
},
|
|
46335
|
+
{
|
|
46336
|
+
"name": "includeFields",
|
|
46337
|
+
"type": "string[]",
|
|
46338
|
+
"optional": true
|
|
46339
|
+
},
|
|
46340
|
+
{
|
|
46341
|
+
"name": "fieldCheck",
|
|
46342
|
+
"type": "boolean",
|
|
46343
|
+
"optional": true,
|
|
46344
|
+
"default": true
|
|
46345
|
+
},
|
|
46346
|
+
{
|
|
46347
|
+
"name": "names",
|
|
46348
|
+
"type": "boolean",
|
|
46349
|
+
"optional": true
|
|
46350
|
+
},
|
|
46351
|
+
{
|
|
46352
|
+
"name": "via",
|
|
46353
|
+
"type": "\"post\" | \"get\"",
|
|
46354
|
+
"optional": true
|
|
46355
|
+
},
|
|
46356
|
+
{
|
|
46357
|
+
"name": "acknowledgeUnscoped",
|
|
46358
|
+
"type": "boolean",
|
|
46359
|
+
"optional": true
|
|
46360
|
+
},
|
|
46361
|
+
{
|
|
46362
|
+
"name": "walk",
|
|
46363
|
+
"type": "object",
|
|
46364
|
+
"optional": true
|
|
46365
|
+
}
|
|
46366
|
+
]
|
|
46367
|
+
}
|
|
46368
|
+
},
|
|
46369
|
+
"inputSchemaStrict": true,
|
|
46370
|
+
"outputSchema": {
|
|
46371
|
+
"type": "QueryActionResult[<Model>,<Entity>]",
|
|
46372
|
+
"drops": []
|
|
46373
|
+
},
|
|
46374
|
+
"examples": [
|
|
46375
|
+
"await client.companyLocations.query({ filter: [{ field: 'name', op: 'eq', value: 'example' }], limit: 500 })"
|
|
46376
|
+
],
|
|
46377
|
+
"permissions": "unknown",
|
|
46378
|
+
"pagination": {
|
|
46379
|
+
"mode": "cursor",
|
|
46380
|
+
"vendorDefault": 10,
|
|
46381
|
+
"vendorMax": 500,
|
|
46382
|
+
"pageGuard": 1000,
|
|
46383
|
+
"queryBounded": {
|
|
46384
|
+
"default": 500,
|
|
46385
|
+
"max": 2500
|
|
46386
|
+
}
|
|
46387
|
+
},
|
|
46388
|
+
"resolution": null,
|
|
46389
|
+
"retry": {
|
|
46390
|
+
"preset": "retry-ffb3a9cb"
|
|
46391
|
+
},
|
|
46392
|
+
"errors": {
|
|
46393
|
+
"set": 4
|
|
46394
|
+
},
|
|
46395
|
+
"metadata": {
|
|
46396
|
+
"purpose": "Query CompanyLocation records with a JSON filter.",
|
|
46397
|
+
"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 companyID eq <parentId> where the parent is known). 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.",
|
|
46398
|
+
"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).",
|
|
46399
|
+
"related": [
|
|
46400
|
+
"company_locations.resolve"
|
|
46401
|
+
],
|
|
46402
|
+
"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. For a simple text lookup prefer company_locations.search. 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.",
|
|
46403
|
+
"untrustedFields": [
|
|
46404
|
+
"description",
|
|
46405
|
+
"name"
|
|
46406
|
+
]
|
|
46407
|
+
},
|
|
46408
|
+
"compact": null,
|
|
46409
|
+
"status": "tested"
|
|
46410
|
+
},
|
|
46411
|
+
{
|
|
46412
|
+
"id": "company_locations.resolve",
|
|
46413
|
+
"resource": "company_locations",
|
|
46414
|
+
"udfCapable": false,
|
|
46415
|
+
"operation": "resolve",
|
|
46416
|
+
"kind": "helper",
|
|
46417
|
+
"endpoint": null,
|
|
46418
|
+
"effect": "read",
|
|
46419
|
+
"flags": [],
|
|
46420
|
+
"dryRun": false,
|
|
46421
|
+
"envelope": null,
|
|
46422
|
+
"inputSchema": {
|
|
46423
|
+
"identifier": {
|
|
46424
|
+
"type": "string | number",
|
|
46425
|
+
"required": true,
|
|
46426
|
+
"description": "A numeric id (the direct fetch, tried first) or an exact value of the primary text field(s) of this resource (exact match only — a complete non-match returns null (resolve never widens to contains; the resource's search op is the contains-candidates channel) — other identifier forms, e.g. an email address, are NOT tried; use the dedicated lookup op for the resource where one exists)."
|
|
46427
|
+
},
|
|
46428
|
+
"opts": {
|
|
46429
|
+
"type": "object",
|
|
46430
|
+
"required": false,
|
|
46431
|
+
"description": "ResolutionOpts — { expand?: boolean } (return the full record; a no-op where the Summary is a structural alias).",
|
|
46432
|
+
"properties": [
|
|
46433
|
+
{
|
|
46434
|
+
"name": "expand",
|
|
46435
|
+
"type": "boolean",
|
|
46436
|
+
"optional": true
|
|
46437
|
+
}
|
|
46438
|
+
]
|
|
46439
|
+
}
|
|
46440
|
+
},
|
|
46441
|
+
"inputSchemaStrict": true,
|
|
46442
|
+
"outputSchema": {
|
|
46443
|
+
"type": "CompanyLocationSummary",
|
|
46444
|
+
"drops": []
|
|
46445
|
+
},
|
|
46446
|
+
"examples": [
|
|
46447
|
+
"await client.companyLocations.resolve('example-value')"
|
|
46448
|
+
],
|
|
46449
|
+
"permissions": "unknown",
|
|
46450
|
+
"pagination": {
|
|
46451
|
+
"mode": "none"
|
|
46452
|
+
},
|
|
46453
|
+
"resolution": {
|
|
46454
|
+
"basis": "server-filter",
|
|
46455
|
+
"maxScanRecords": 500,
|
|
46456
|
+
"maxScanPages": 4
|
|
46457
|
+
},
|
|
46458
|
+
"retry": {
|
|
46459
|
+
"preset": "retry-ffb3a9cb"
|
|
46460
|
+
},
|
|
46461
|
+
"errors": {
|
|
46462
|
+
"set": 5
|
|
46463
|
+
},
|
|
46464
|
+
"metadata": {
|
|
46465
|
+
"purpose": "Resolve a company location from a numeric id (the direct fetch, tried first) or an exact value of its primary text field(s) (name — exact match only). Returns the Company location record with the numeric id for get/update/delete. Other identifier forms (e.g. an email address) are NOT tried by resolve — use the resource's dedicated lookup op where one exists (see autotask_catalog).",
|
|
46466
|
+
"usage": "Bare values are read in the order: numeric id, then the resource primary text field (see searchCovers), exact match only. { id } miss throws NOT_FOUND.",
|
|
46467
|
+
"preferredWhen": null,
|
|
46468
|
+
"related": [
|
|
46469
|
+
"company_locations.get"
|
|
46470
|
+
],
|
|
46471
|
+
"untrustedFields": [
|
|
46472
|
+
"description",
|
|
46473
|
+
"name"
|
|
46474
|
+
]
|
|
46475
|
+
},
|
|
46476
|
+
"compact": "CompanyLocationSummary",
|
|
46477
|
+
"status": "tested"
|
|
46478
|
+
},
|
|
46479
|
+
{
|
|
46480
|
+
"id": "company_locations.search",
|
|
46481
|
+
"resource": "company_locations",
|
|
46482
|
+
"udfCapable": false,
|
|
46483
|
+
"operation": "search",
|
|
46484
|
+
"kind": "helper",
|
|
46485
|
+
"endpoint": null,
|
|
46486
|
+
"effect": "read",
|
|
46487
|
+
"flags": [],
|
|
46488
|
+
"dryRun": false,
|
|
46489
|
+
"envelope": null,
|
|
46490
|
+
"inputSchema": {
|
|
46491
|
+
"query": {
|
|
46492
|
+
"type": "string",
|
|
46493
|
+
"required": true,
|
|
46494
|
+
"description": "The free text to match (contains) on the resource searchable fields."
|
|
46495
|
+
},
|
|
46496
|
+
"opts": {
|
|
46497
|
+
"type": "object",
|
|
46498
|
+
"required": false,
|
|
46499
|
+
"description": "SearchOpts — { limit?: number } (1-500, default 25).",
|
|
46500
|
+
"properties": [
|
|
46501
|
+
{
|
|
46502
|
+
"name": "limit",
|
|
46503
|
+
"type": "number",
|
|
46504
|
+
"optional": true
|
|
46505
|
+
}
|
|
46506
|
+
]
|
|
46507
|
+
}
|
|
46508
|
+
},
|
|
46509
|
+
"inputSchemaStrict": true,
|
|
46510
|
+
"outputSchema": {
|
|
46511
|
+
"type": "CompanyLocationSummary",
|
|
46512
|
+
"drops": []
|
|
46513
|
+
},
|
|
46514
|
+
"examples": [
|
|
46515
|
+
"await client.companyLocations.search('example')"
|
|
46516
|
+
],
|
|
46517
|
+
"permissions": "unknown",
|
|
46518
|
+
"pagination": {
|
|
46519
|
+
"mode": "none"
|
|
46520
|
+
},
|
|
46521
|
+
"resolution": {
|
|
46522
|
+
"basis": "server-filter",
|
|
46523
|
+
"maxScanRecords": 500,
|
|
46524
|
+
"maxScanPages": 4
|
|
46525
|
+
},
|
|
46526
|
+
"retry": {
|
|
46527
|
+
"preset": "retry-ffb3a9cb"
|
|
46528
|
+
},
|
|
46529
|
+
"errors": {
|
|
46530
|
+
"set": 5
|
|
46531
|
+
},
|
|
46532
|
+
"metadata": {
|
|
46533
|
+
"purpose": "Search company location records by text (contains on the searchable fields).",
|
|
46534
|
+
"usage": "Vendor exposes no free-text search; this is a bounded contains filter: name only (contains). limit defaults to 25, max 500.",
|
|
46535
|
+
"preferredWhen": null,
|
|
46536
|
+
"related": [
|
|
46537
|
+
"company_locations.resolve",
|
|
46538
|
+
"company_locations.query"
|
|
46539
|
+
],
|
|
46540
|
+
"untrustedFields": [
|
|
46541
|
+
"description",
|
|
46542
|
+
"name"
|
|
46543
|
+
]
|
|
46544
|
+
},
|
|
46545
|
+
"compact": "CompanyLocationSummary",
|
|
46546
|
+
"status": "tested"
|
|
46547
|
+
},
|
|
46548
|
+
{
|
|
46549
|
+
"id": "company_locations.update",
|
|
46550
|
+
"resource": "company_locations",
|
|
46551
|
+
"udfCapable": false,
|
|
46552
|
+
"operation": "update",
|
|
46553
|
+
"kind": "primitive",
|
|
46554
|
+
"endpoint": "PUT|PATCH /V1.0/Companies/{parentId}/Locations",
|
|
46555
|
+
"effect": "write",
|
|
46556
|
+
"flags": [
|
|
46557
|
+
"idempotent"
|
|
46558
|
+
],
|
|
46559
|
+
"dryRun": true,
|
|
46560
|
+
"envelope": "OperationResultModel",
|
|
46561
|
+
"inputSchema": {
|
|
46562
|
+
"parentId": {
|
|
46563
|
+
"type": "string | number",
|
|
46564
|
+
"required": true,
|
|
46565
|
+
"description": "The parent record id (parent-scoped collection; number, or a canonical integer string)."
|
|
46566
|
+
},
|
|
46567
|
+
"id": {
|
|
46568
|
+
"type": "string | number",
|
|
46569
|
+
"required": true,
|
|
46570
|
+
"description": "The record id (number, or a canonical integer string — ids beyond 2^53 are supported via the string form)."
|
|
46571
|
+
},
|
|
46572
|
+
"data": {
|
|
46573
|
+
"type": "object",
|
|
46574
|
+
"required": true,
|
|
46575
|
+
"description": "The record payload (vendor model fields)."
|
|
46576
|
+
}
|
|
46577
|
+
},
|
|
46578
|
+
"inputSchemaStrict": true,
|
|
46579
|
+
"outputSchema": {
|
|
46580
|
+
"type": "OperationResultModel",
|
|
46581
|
+
"drops": []
|
|
46582
|
+
},
|
|
46583
|
+
"examples": [
|
|
46584
|
+
"await client.companyLocations.update('example-value', 'example-value', { name: 'example' }, { dryRun: true })"
|
|
46585
|
+
],
|
|
46586
|
+
"permissions": "unknown",
|
|
46587
|
+
"pagination": {
|
|
46588
|
+
"mode": "none"
|
|
46589
|
+
},
|
|
46590
|
+
"resolution": null,
|
|
46591
|
+
"retry": {
|
|
46592
|
+
"preset": "retry-85897a3a"
|
|
46593
|
+
},
|
|
46594
|
+
"errors": {
|
|
46595
|
+
"set": 1
|
|
46596
|
+
},
|
|
46597
|
+
"metadata": {
|
|
46598
|
+
"purpose": "Update a company location.",
|
|
46599
|
+
"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.",
|
|
46600
|
+
"preferredWhen": "Preferred over create or delete when the record exists and only some fields change.",
|
|
46601
|
+
"related": [
|
|
46602
|
+
"company_locations.get"
|
|
46603
|
+
],
|
|
46604
|
+
"untrustedFields": [
|
|
46605
|
+
"description",
|
|
46606
|
+
"name"
|
|
46607
|
+
]
|
|
46608
|
+
},
|
|
46609
|
+
"compact": null,
|
|
46610
|
+
"status": "tested"
|
|
46611
|
+
},
|
|
46612
|
+
{
|
|
46613
|
+
"id": "company_note_attachments.count",
|
|
46614
|
+
"resource": "company_note_attachments",
|
|
46615
|
+
"udfCapable": false,
|
|
46616
|
+
"operation": "count",
|
|
46617
|
+
"kind": "primitive",
|
|
46618
|
+
"endpoint": "GET|POST /V1.0/CompanyNoteAttachments/query/count",
|
|
46619
|
+
"effect": "read",
|
|
46620
|
+
"flags": [],
|
|
46621
|
+
"dryRun": false,
|
|
46622
|
+
"envelope": "QueryCountResultModel",
|
|
46623
|
+
"inputSchema": {
|
|
46624
|
+
"params": {
|
|
46625
|
+
"type": "object",
|
|
46626
|
+
"required": false,
|
|
46627
|
+
"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.",
|
|
46628
|
+
"properties": [
|
|
46629
|
+
{
|
|
46630
|
+
"name": "filter",
|
|
46631
|
+
"type": "FilterCondition[]",
|
|
46632
|
+
"optional": true
|
|
46633
|
+
},
|
|
46634
|
+
{
|
|
46635
|
+
"name": "fieldCheck",
|
|
46636
|
+
"type": "boolean",
|
|
46637
|
+
"optional": true
|
|
46638
|
+
}
|
|
46639
|
+
]
|
|
46640
|
+
}
|
|
46641
|
+
},
|
|
46642
|
+
"inputSchemaStrict": true,
|
|
46643
|
+
"outputSchema": {
|
|
46644
|
+
"type": "QueryCountResultModel",
|
|
46645
|
+
"drops": []
|
|
46646
|
+
},
|
|
46647
|
+
"examples": [
|
|
46648
|
+
"await client.companyNoteAttachments.count({ filter: [{ field: 'companyNoteID', op: 'eq', value: 1 }] })"
|
|
46649
|
+
],
|
|
46650
|
+
"permissions": "unknown",
|
|
46651
|
+
"pagination": {
|
|
46652
|
+
"mode": "none"
|
|
46653
|
+
},
|
|
46654
|
+
"resolution": null,
|
|
46655
|
+
"retry": {
|
|
46656
|
+
"preset": "retry-ffb3a9cb"
|
|
46657
|
+
},
|
|
46658
|
+
"errors": {
|
|
46659
|
+
"set": 0
|
|
46660
|
+
},
|
|
46661
|
+
"metadata": {
|
|
46662
|
+
"purpose": "Count attachment records matching a JSON filter. (under a company note)",
|
|
46663
|
+
"usage": "Unwraps queryCount; returns a plain number. Filter by companyNoteID for the note parent; companyID is a separate company reference. creatorType, data and fileSize are not queryable. Object-specific filters can include child attachments; an empty result is conditional on API-user permissions and visibility.",
|
|
46664
|
+
"preferredWhen": null,
|
|
46665
|
+
"related": [
|
|
46666
|
+
"company_note_attachments.query"
|
|
46667
|
+
],
|
|
46668
|
+
"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.",
|
|
46669
|
+
"untrustedFields": [
|
|
46670
|
+
"title"
|
|
46671
|
+
]
|
|
46672
|
+
},
|
|
46673
|
+
"compact": null,
|
|
46674
|
+
"status": "tested"
|
|
46675
|
+
},
|
|
46676
|
+
{
|
|
46677
|
+
"id": "company_note_attachments.create",
|
|
46678
|
+
"resource": "company_note_attachments",
|
|
46679
|
+
"udfCapable": false,
|
|
46680
|
+
"operation": "create",
|
|
46681
|
+
"kind": "primitive",
|
|
46682
|
+
"endpoint": "POST /V1.0/CompanyNotes/{parentId}/Attachments",
|
|
46683
|
+
"effect": "write",
|
|
46684
|
+
"flags": [],
|
|
46685
|
+
"dryRun": true,
|
|
46686
|
+
"envelope": "OperationResultModel",
|
|
46687
|
+
"inputSchema": {
|
|
46688
|
+
"parentId": {
|
|
46689
|
+
"type": "string | number",
|
|
46690
|
+
"required": true,
|
|
46691
|
+
"description": "The parent record id (parent-scoped collection; number, or a canonical integer string)."
|
|
46692
|
+
},
|
|
46693
|
+
"data": {
|
|
46694
|
+
"type": "object",
|
|
46695
|
+
"required": true,
|
|
46696
|
+
"description": "The record payload (vendor model fields)."
|
|
46697
|
+
}
|
|
46698
|
+
},
|
|
46699
|
+
"inputSchemaStrict": true,
|
|
46700
|
+
"outputSchema": {
|
|
46701
|
+
"type": "OperationResultModel",
|
|
46702
|
+
"drops": []
|
|
46703
|
+
},
|
|
46704
|
+
"examples": [
|
|
46705
|
+
"await client.companyNoteAttachments.create(1, { attachmentType: 'FILE_ATTACHMENT', fullPath: 'note.txt', title: 'Supporting note', publish: 1, data: 'bm90ZQ==' }, { dryRun: true })"
|
|
46706
|
+
],
|
|
46707
|
+
"permissions": "unknown",
|
|
46708
|
+
"pagination": {
|
|
46709
|
+
"mode": "none"
|
|
46710
|
+
},
|
|
46711
|
+
"resolution": null,
|
|
46712
|
+
"retry": {
|
|
46713
|
+
"preset": "retry-c5657094"
|
|
46714
|
+
},
|
|
46715
|
+
"errors": {
|
|
46716
|
+
"set": 1
|
|
46717
|
+
},
|
|
46718
|
+
"metadata": {
|
|
46719
|
+
"purpose": "Create an attachment. (under a company note)",
|
|
46720
|
+
"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. FILE_ATTACHMENT requires base64 data; use current attachmentType/publish metadata and vendor file limits. ParentId addresses the CompanyNotes record. Permission and impersonation restrictions apply.",
|
|
46721
|
+
"preferredWhen": "Add a new attachment; existing attachments cannot be updated. Replace through separately governed delete and create actions.",
|
|
46722
|
+
"related": [
|
|
46723
|
+
"company_note_attachments.get"
|
|
46724
|
+
],
|
|
46725
|
+
"untrustedFields": [
|
|
46726
|
+
"title"
|
|
46727
|
+
],
|
|
46728
|
+
"createRequirements": {
|
|
46729
|
+
"requiresByValue": [
|
|
46730
|
+
{
|
|
46731
|
+
"field": "attachmentType",
|
|
46732
|
+
"value": "FILE_ATTACHMENT",
|
|
46733
|
+
"requires": {
|
|
46734
|
+
"allOf": [
|
|
46735
|
+
"data"
|
|
46736
|
+
]
|
|
46737
|
+
}
|
|
46738
|
+
}
|
|
46739
|
+
]
|
|
46740
|
+
}
|
|
46741
|
+
},
|
|
46742
|
+
"compact": null,
|
|
46743
|
+
"status": "tested"
|
|
46744
|
+
},
|
|
46745
|
+
{
|
|
46746
|
+
"id": "company_note_attachments.delete",
|
|
46747
|
+
"resource": "company_note_attachments",
|
|
46748
|
+
"udfCapable": false,
|
|
46749
|
+
"operation": "delete",
|
|
46750
|
+
"kind": "primitive",
|
|
46751
|
+
"endpoint": "DELETE /V1.0/CompanyNotes/{parentId}/Attachments/{id}",
|
|
46752
|
+
"effect": "destructive",
|
|
46753
|
+
"flags": [
|
|
46754
|
+
"idempotent",
|
|
46755
|
+
"requiresApproval"
|
|
46756
|
+
],
|
|
46757
|
+
"dryRun": true,
|
|
46758
|
+
"envelope": "OperationResultModel (attachment entities: the deleted attachment model is returned, not OperationResultModel)",
|
|
46759
|
+
"inputSchema": {
|
|
46760
|
+
"parentId": {
|
|
46761
|
+
"type": "string | number",
|
|
46762
|
+
"required": true,
|
|
46763
|
+
"description": "The parent record id (parent-scoped collection; number, or a canonical integer string)."
|
|
46764
|
+
},
|
|
46765
|
+
"id": {
|
|
46766
|
+
"type": "string | number",
|
|
46767
|
+
"required": true,
|
|
46768
|
+
"description": "The record id (number, or a canonical integer string — ids beyond 2^53 are supported via the string form)."
|
|
46769
|
+
}
|
|
46770
|
+
},
|
|
46771
|
+
"inputSchemaStrict": true,
|
|
46772
|
+
"outputSchema": {
|
|
46773
|
+
"type": "OperationResultModel (attachment entities: the deleted attachment model is returned, not OperationResultModel)",
|
|
46774
|
+
"drops": []
|
|
46775
|
+
},
|
|
46776
|
+
"examples": [
|
|
46777
|
+
"await invoke(client, 'company_note_attachments.delete', ['example-value', 'example-value'], { dryRun: false, confirm: 'company_note_attachments.delete' })"
|
|
46778
|
+
],
|
|
46779
|
+
"permissions": "unknown",
|
|
46780
|
+
"pagination": {
|
|
46781
|
+
"mode": "none"
|
|
46782
|
+
},
|
|
46783
|
+
"resolution": null,
|
|
46784
|
+
"retry": {
|
|
46785
|
+
"preset": "retry-1849870d"
|
|
46786
|
+
},
|
|
46787
|
+
"errors": {
|
|
46788
|
+
"set": 2
|
|
46789
|
+
},
|
|
46790
|
+
"metadata": {
|
|
46791
|
+
"purpose": "Delete an attachment. (under a company note)",
|
|
46792
|
+
"usage": "Irreversible; dry-run validates the target id first. Parent-scoped: parentId + id.",
|
|
46793
|
+
"preferredWhen": null,
|
|
46794
|
+
"related": [
|
|
46795
|
+
"company_note_attachments.get"
|
|
46796
|
+
],
|
|
46797
|
+
"untrustedFields": [
|
|
46798
|
+
"title"
|
|
46799
|
+
]
|
|
46800
|
+
},
|
|
46801
|
+
"compact": null,
|
|
46802
|
+
"status": "tested"
|
|
46803
|
+
},
|
|
46804
|
+
{
|
|
46805
|
+
"id": "company_note_attachments.get",
|
|
46806
|
+
"resource": "company_note_attachments",
|
|
46807
|
+
"udfCapable": false,
|
|
46808
|
+
"operation": "get",
|
|
46809
|
+
"kind": "primitive",
|
|
46810
|
+
"endpoint": "GET /V1.0/CompanyNotes/{parentId}/Attachments/{id}",
|
|
46811
|
+
"effect": "read",
|
|
46812
|
+
"flags": [],
|
|
46813
|
+
"dryRun": false,
|
|
46814
|
+
"envelope": "CompanyNoteAttachmentModel",
|
|
46815
|
+
"inputSchema": {
|
|
46816
|
+
"parentId": {
|
|
46817
|
+
"type": "string | number",
|
|
46818
|
+
"required": true,
|
|
46819
|
+
"description": "The parent record id (parent-scoped collection; number, or a canonical integer string)."
|
|
46820
|
+
},
|
|
46821
|
+
"id": {
|
|
46822
|
+
"type": "string | number",
|
|
46823
|
+
"required": true,
|
|
46824
|
+
"description": "The record id (number, or a canonical integer string — ids beyond 2^53 are supported via the string form)."
|
|
46825
|
+
},
|
|
46826
|
+
"opts": {
|
|
46827
|
+
"type": "object",
|
|
46828
|
+
"required": false,
|
|
46829
|
+
"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.",
|
|
46830
|
+
"properties": [
|
|
46831
|
+
{
|
|
46832
|
+
"name": "fresh",
|
|
46833
|
+
"type": "boolean",
|
|
46834
|
+
"optional": true
|
|
46835
|
+
}
|
|
46836
|
+
]
|
|
46837
|
+
}
|
|
46838
|
+
},
|
|
46839
|
+
"inputSchemaStrict": true,
|
|
46840
|
+
"outputSchema": {
|
|
46841
|
+
"type": "CompanyNoteAttachmentModel",
|
|
45285
46842
|
"drops": []
|
|
45286
46843
|
},
|
|
45287
46844
|
"examples": [
|
|
45288
|
-
"await client.
|
|
46845
|
+
"await client.companyNoteAttachments.get('example-value', 'example-value')"
|
|
45289
46846
|
],
|
|
45290
46847
|
"permissions": "unknown",
|
|
45291
46848
|
"pagination": {
|
|
@@ -45299,28 +46856,27 @@
|
|
|
45299
46856
|
"set": 3
|
|
45300
46857
|
},
|
|
45301
46858
|
"metadata": {
|
|
45302
|
-
"purpose": "Get one
|
|
45303
|
-
"usage": "item: null
|
|
45304
|
-
"preferredWhen": "
|
|
46859
|
+
"purpose": "Get one CompanyNoteAttachment by id.",
|
|
46860
|
+
"usage": "Returns the attachment model directly; item: null or an empty model is a typed not-found. Parent-scoped: parentId is the company note id, followed by the attachment id.",
|
|
46861
|
+
"preferredWhen": "Use a known attachment id; query the scoped collection to discover ids.",
|
|
45305
46862
|
"related": [
|
|
45306
|
-
"
|
|
46863
|
+
"company_note_attachments.query"
|
|
45307
46864
|
],
|
|
45308
|
-
"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
|
|
46865
|
+
"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 a company_note_attachments.query with includeFields.",
|
|
45309
46866
|
"untrustedFields": [
|
|
45310
|
-
"
|
|
45311
|
-
"name"
|
|
46867
|
+
"title"
|
|
45312
46868
|
]
|
|
45313
46869
|
},
|
|
45314
46870
|
"compact": null,
|
|
45315
46871
|
"status": "tested"
|
|
45316
46872
|
},
|
|
45317
46873
|
{
|
|
45318
|
-
"id": "
|
|
45319
|
-
"resource": "
|
|
46874
|
+
"id": "company_note_attachments.getEntityInfo",
|
|
46875
|
+
"resource": "company_note_attachments",
|
|
45320
46876
|
"udfCapable": false,
|
|
45321
46877
|
"operation": "getEntityInfo",
|
|
45322
46878
|
"kind": "primitive",
|
|
45323
|
-
"endpoint": "GET /V1.0/
|
|
46879
|
+
"endpoint": "GET /V1.0/CompanyNoteAttachments/entityInformation",
|
|
45324
46880
|
"effect": "read",
|
|
45325
46881
|
"flags": [],
|
|
45326
46882
|
"dryRun": false,
|
|
@@ -45332,7 +46888,7 @@
|
|
|
45332
46888
|
"drops": []
|
|
45333
46889
|
},
|
|
45334
46890
|
"examples": [
|
|
45335
|
-
"await client.
|
|
46891
|
+
"await client.companyNoteAttachments.getEntityInfo()"
|
|
45336
46892
|
],
|
|
45337
46893
|
"permissions": "unknown",
|
|
45338
46894
|
"pagination": {
|
|
@@ -45346,27 +46902,26 @@
|
|
|
45346
46902
|
"set": 0
|
|
45347
46903
|
},
|
|
45348
46904
|
"metadata": {
|
|
45349
|
-
"purpose": "Get the
|
|
46905
|
+
"purpose": "Get the CompanyNoteAttachment capability metadata (canCreate/canUpdate/hasUserDefinedFields/...).",
|
|
45350
46906
|
"usage": "Unwraps info{}; drives client-side capability checks.",
|
|
45351
46907
|
"preferredWhen": null,
|
|
45352
46908
|
"related": [
|
|
45353
|
-
"
|
|
46909
|
+
"company_note_attachments.getFieldInfo"
|
|
45354
46910
|
],
|
|
45355
46911
|
"untrustedFields": [
|
|
45356
|
-
"
|
|
45357
|
-
"name"
|
|
46912
|
+
"title"
|
|
45358
46913
|
]
|
|
45359
46914
|
},
|
|
45360
46915
|
"compact": null,
|
|
45361
46916
|
"status": "tested"
|
|
45362
46917
|
},
|
|
45363
46918
|
{
|
|
45364
|
-
"id": "
|
|
45365
|
-
"resource": "
|
|
46919
|
+
"id": "company_note_attachments.getFieldInfo",
|
|
46920
|
+
"resource": "company_note_attachments",
|
|
45366
46921
|
"udfCapable": false,
|
|
45367
46922
|
"operation": "getFieldInfo",
|
|
45368
46923
|
"kind": "primitive",
|
|
45369
|
-
"endpoint": "GET /V1.0/
|
|
46924
|
+
"endpoint": "GET /V1.0/CompanyNoteAttachments/entityInformation/fields",
|
|
45370
46925
|
"effect": "read",
|
|
45371
46926
|
"flags": [],
|
|
45372
46927
|
"dryRun": false,
|
|
@@ -45378,7 +46933,7 @@
|
|
|
45378
46933
|
"drops": []
|
|
45379
46934
|
},
|
|
45380
46935
|
"examples": [
|
|
45381
|
-
"await client.
|
|
46936
|
+
"await client.companyNoteAttachments.getFieldInfo()"
|
|
45382
46937
|
],
|
|
45383
46938
|
"permissions": "unknown",
|
|
45384
46939
|
"pagination": {
|
|
@@ -45392,74 +46947,26 @@
|
|
|
45392
46947
|
"set": 0
|
|
45393
46948
|
},
|
|
45394
46949
|
"metadata": {
|
|
45395
|
-
"purpose": "Get the
|
|
46950
|
+
"purpose": "Get the CompanyNoteAttachment field catalog (types, picklists, required, maxLength) — the full raw field dump (the largest read of the info trio; compact discovery: operations.fieldCatalog).",
|
|
45396
46951
|
"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.",
|
|
45397
46952
|
"preferredWhen": null,
|
|
45398
46953
|
"related": [
|
|
45399
|
-
"
|
|
45400
|
-
"company_locations.getUdfInfo"
|
|
46954
|
+
"company_note_attachments.getEntityInfo"
|
|
45401
46955
|
],
|
|
45402
46956
|
"untrustedFields": [
|
|
45403
|
-
"
|
|
45404
|
-
"name"
|
|
45405
|
-
]
|
|
45406
|
-
},
|
|
45407
|
-
"compact": null,
|
|
45408
|
-
"status": "tested"
|
|
45409
|
-
},
|
|
45410
|
-
{
|
|
45411
|
-
"id": "company_locations.getUdfInfo",
|
|
45412
|
-
"resource": "company_locations",
|
|
45413
|
-
"udfCapable": false,
|
|
45414
|
-
"operation": "getUdfInfo",
|
|
45415
|
-
"kind": "primitive",
|
|
45416
|
-
"endpoint": "GET /V1.0/CompanyLocations/entityInformation/userDefinedFields",
|
|
45417
|
-
"effect": "read",
|
|
45418
|
-
"flags": [],
|
|
45419
|
-
"dryRun": false,
|
|
45420
|
-
"envelope": "UserDefinedFieldInformationResultModel",
|
|
45421
|
-
"inputSchema": {},
|
|
45422
|
-
"inputSchemaStrict": true,
|
|
45423
|
-
"outputSchema": {
|
|
45424
|
-
"type": "UserDefinedFieldInformationResultModel",
|
|
45425
|
-
"drops": []
|
|
45426
|
-
},
|
|
45427
|
-
"examples": [
|
|
45428
|
-
"await client.companyLocations.getUdfInfo()"
|
|
45429
|
-
],
|
|
45430
|
-
"permissions": "unknown",
|
|
45431
|
-
"pagination": {
|
|
45432
|
-
"mode": "none"
|
|
45433
|
-
},
|
|
45434
|
-
"resolution": null,
|
|
45435
|
-
"retry": {
|
|
45436
|
-
"preset": "retry-ffb3a9cb"
|
|
45437
|
-
},
|
|
45438
|
-
"errors": {
|
|
45439
|
-
"set": 0
|
|
45440
|
-
},
|
|
45441
|
-
"metadata": {
|
|
45442
|
-
"purpose": "Get the CompanyLocation user-defined-field catalog.",
|
|
45443
|
-
"usage": "Unwraps fields[]; only meaningful where the entity is UDF-capable. (entity is not UDF-capable; catalog is expected empty).",
|
|
45444
|
-
"preferredWhen": null,
|
|
45445
|
-
"related": [
|
|
45446
|
-
"company_locations.getFieldInfo"
|
|
45447
|
-
],
|
|
45448
|
-
"untrustedFields": [
|
|
45449
|
-
"description",
|
|
45450
|
-
"name"
|
|
46957
|
+
"title"
|
|
45451
46958
|
]
|
|
45452
46959
|
},
|
|
45453
46960
|
"compact": null,
|
|
45454
46961
|
"status": "tested"
|
|
45455
46962
|
},
|
|
45456
46963
|
{
|
|
45457
|
-
"id": "
|
|
45458
|
-
"resource": "
|
|
46964
|
+
"id": "company_note_attachments.query",
|
|
46965
|
+
"resource": "company_note_attachments",
|
|
45459
46966
|
"udfCapable": false,
|
|
45460
46967
|
"operation": "query",
|
|
45461
46968
|
"kind": "primitive",
|
|
45462
|
-
"endpoint": "GET|POST /V1.0/
|
|
46969
|
+
"endpoint": "GET|POST /V1.0/CompanyNoteAttachments/query",
|
|
45463
46970
|
"effect": "read",
|
|
45464
46971
|
"flags": [],
|
|
45465
46972
|
"dryRun": false,
|
|
@@ -45531,7 +47038,7 @@
|
|
|
45531
47038
|
"drops": []
|
|
45532
47039
|
},
|
|
45533
47040
|
"examples": [
|
|
45534
|
-
"await client.
|
|
47041
|
+
"await client.companyNoteAttachments.query({ filter: [{ field: 'companyNoteID', op: 'eq', value: 1 }], limit: 25 })"
|
|
45535
47042
|
],
|
|
45536
47043
|
"permissions": "unknown",
|
|
45537
47044
|
"pagination": {
|
|
@@ -45552,217 +47059,15 @@
|
|
|
45552
47059
|
"set": 4
|
|
45553
47060
|
},
|
|
45554
47061
|
"metadata": {
|
|
45555
|
-
"purpose": "Query
|
|
45556
|
-
"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
|
|
47062
|
+
"purpose": "Query CompanyNoteAttachment records with a JSON filter.",
|
|
47063
|
+
"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 companyNoteID eq <parentId> where the parent is known). 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. Filter by companyNoteID for the note parent; companyID is a separate company reference. creatorType, data and fileSize are not queryable. Object-specific filters can include child attachments; an empty result is conditional on API-user permissions and visibility. The Swagger query response names an attachment model, while this collection uses the existing SDK attachment query contract { items, pageDetails }; a bare-model response is rejected as INVALID_RESPONSE rather than guessed into a collection.",
|
|
45557
47064
|
"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).",
|
|
45558
47065
|
"related": [
|
|
45559
|
-
"
|
|
45560
|
-
],
|
|
45561
|
-
"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. For a simple text lookup prefer company_locations.search. 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.",
|
|
45562
|
-
"untrustedFields": [
|
|
45563
|
-
"description",
|
|
45564
|
-
"name"
|
|
45565
|
-
]
|
|
45566
|
-
},
|
|
45567
|
-
"compact": null,
|
|
45568
|
-
"status": "tested"
|
|
45569
|
-
},
|
|
45570
|
-
{
|
|
45571
|
-
"id": "company_locations.resolve",
|
|
45572
|
-
"resource": "company_locations",
|
|
45573
|
-
"udfCapable": false,
|
|
45574
|
-
"operation": "resolve",
|
|
45575
|
-
"kind": "helper",
|
|
45576
|
-
"endpoint": null,
|
|
45577
|
-
"effect": "read",
|
|
45578
|
-
"flags": [],
|
|
45579
|
-
"dryRun": false,
|
|
45580
|
-
"envelope": null,
|
|
45581
|
-
"inputSchema": {
|
|
45582
|
-
"identifier": {
|
|
45583
|
-
"type": "string | number",
|
|
45584
|
-
"required": true,
|
|
45585
|
-
"description": "A numeric id (the direct fetch, tried first) or an exact value of the primary text field(s) of this resource (exact match only — a complete non-match returns null (resolve never widens to contains; the resource's search op is the contains-candidates channel) — other identifier forms, e.g. an email address, are NOT tried; use the dedicated lookup op for the resource where one exists)."
|
|
45586
|
-
},
|
|
45587
|
-
"opts": {
|
|
45588
|
-
"type": "object",
|
|
45589
|
-
"required": false,
|
|
45590
|
-
"description": "ResolutionOpts — { expand?: boolean } (return the full record; a no-op where the Summary is a structural alias).",
|
|
45591
|
-
"properties": [
|
|
45592
|
-
{
|
|
45593
|
-
"name": "expand",
|
|
45594
|
-
"type": "boolean",
|
|
45595
|
-
"optional": true
|
|
45596
|
-
}
|
|
45597
|
-
]
|
|
45598
|
-
}
|
|
45599
|
-
},
|
|
45600
|
-
"inputSchemaStrict": true,
|
|
45601
|
-
"outputSchema": {
|
|
45602
|
-
"type": "CompanyLocationSummary",
|
|
45603
|
-
"drops": []
|
|
45604
|
-
},
|
|
45605
|
-
"examples": [
|
|
45606
|
-
"await client.companyLocations.resolve('example-value')"
|
|
45607
|
-
],
|
|
45608
|
-
"permissions": "unknown",
|
|
45609
|
-
"pagination": {
|
|
45610
|
-
"mode": "none"
|
|
45611
|
-
},
|
|
45612
|
-
"resolution": {
|
|
45613
|
-
"basis": "server-filter",
|
|
45614
|
-
"maxScanRecords": 500,
|
|
45615
|
-
"maxScanPages": 4
|
|
45616
|
-
},
|
|
45617
|
-
"retry": {
|
|
45618
|
-
"preset": "retry-ffb3a9cb"
|
|
45619
|
-
},
|
|
45620
|
-
"errors": {
|
|
45621
|
-
"set": 5
|
|
45622
|
-
},
|
|
45623
|
-
"metadata": {
|
|
45624
|
-
"purpose": "Resolve a company location from a numeric id (the direct fetch, tried first) or an exact value of its primary text field(s) (name — exact match only). Returns the Company location record with the numeric id for get/update/delete. Other identifier forms (e.g. an email address) are NOT tried by resolve — use the resource's dedicated lookup op where one exists (see autotask_catalog).",
|
|
45625
|
-
"usage": "Bare values are read in the order: numeric id, then the resource primary text field (see searchCovers), exact match only. { id } miss throws NOT_FOUND.",
|
|
45626
|
-
"preferredWhen": null,
|
|
45627
|
-
"related": [
|
|
45628
|
-
"company_locations.get"
|
|
45629
|
-
],
|
|
45630
|
-
"untrustedFields": [
|
|
45631
|
-
"description",
|
|
45632
|
-
"name"
|
|
45633
|
-
]
|
|
45634
|
-
},
|
|
45635
|
-
"compact": "CompanyLocationSummary",
|
|
45636
|
-
"status": "tested"
|
|
45637
|
-
},
|
|
45638
|
-
{
|
|
45639
|
-
"id": "company_locations.search",
|
|
45640
|
-
"resource": "company_locations",
|
|
45641
|
-
"udfCapable": false,
|
|
45642
|
-
"operation": "search",
|
|
45643
|
-
"kind": "helper",
|
|
45644
|
-
"endpoint": null,
|
|
45645
|
-
"effect": "read",
|
|
45646
|
-
"flags": [],
|
|
45647
|
-
"dryRun": false,
|
|
45648
|
-
"envelope": null,
|
|
45649
|
-
"inputSchema": {
|
|
45650
|
-
"query": {
|
|
45651
|
-
"type": "string",
|
|
45652
|
-
"required": true,
|
|
45653
|
-
"description": "The free text to match (contains) on the resource searchable fields."
|
|
45654
|
-
},
|
|
45655
|
-
"opts": {
|
|
45656
|
-
"type": "object",
|
|
45657
|
-
"required": false,
|
|
45658
|
-
"description": "SearchOpts — { limit?: number } (1-500, default 25).",
|
|
45659
|
-
"properties": [
|
|
45660
|
-
{
|
|
45661
|
-
"name": "limit",
|
|
45662
|
-
"type": "number",
|
|
45663
|
-
"optional": true
|
|
45664
|
-
}
|
|
45665
|
-
]
|
|
45666
|
-
}
|
|
45667
|
-
},
|
|
45668
|
-
"inputSchemaStrict": true,
|
|
45669
|
-
"outputSchema": {
|
|
45670
|
-
"type": "CompanyLocationSummary",
|
|
45671
|
-
"drops": []
|
|
45672
|
-
},
|
|
45673
|
-
"examples": [
|
|
45674
|
-
"await client.companyLocations.search('example')"
|
|
45675
|
-
],
|
|
45676
|
-
"permissions": "unknown",
|
|
45677
|
-
"pagination": {
|
|
45678
|
-
"mode": "none"
|
|
45679
|
-
},
|
|
45680
|
-
"resolution": {
|
|
45681
|
-
"basis": "server-filter",
|
|
45682
|
-
"maxScanRecords": 500,
|
|
45683
|
-
"maxScanPages": 4
|
|
45684
|
-
},
|
|
45685
|
-
"retry": {
|
|
45686
|
-
"preset": "retry-ffb3a9cb"
|
|
45687
|
-
},
|
|
45688
|
-
"errors": {
|
|
45689
|
-
"set": 5
|
|
45690
|
-
},
|
|
45691
|
-
"metadata": {
|
|
45692
|
-
"purpose": "Search company location records by text (contains on the searchable fields).",
|
|
45693
|
-
"usage": "Vendor exposes no free-text search; this is a bounded contains filter: name only (contains). limit defaults to 25, max 500.",
|
|
45694
|
-
"preferredWhen": null,
|
|
45695
|
-
"related": [
|
|
45696
|
-
"company_locations.resolve",
|
|
45697
|
-
"company_locations.query"
|
|
45698
|
-
],
|
|
45699
|
-
"untrustedFields": [
|
|
45700
|
-
"description",
|
|
45701
|
-
"name"
|
|
45702
|
-
]
|
|
45703
|
-
},
|
|
45704
|
-
"compact": "CompanyLocationSummary",
|
|
45705
|
-
"status": "tested"
|
|
45706
|
-
},
|
|
45707
|
-
{
|
|
45708
|
-
"id": "company_locations.update",
|
|
45709
|
-
"resource": "company_locations",
|
|
45710
|
-
"udfCapable": false,
|
|
45711
|
-
"operation": "update",
|
|
45712
|
-
"kind": "primitive",
|
|
45713
|
-
"endpoint": "PUT|PATCH /V1.0/Companies/{parentId}/Locations",
|
|
45714
|
-
"effect": "write",
|
|
45715
|
-
"flags": [
|
|
45716
|
-
"idempotent"
|
|
45717
|
-
],
|
|
45718
|
-
"dryRun": true,
|
|
45719
|
-
"envelope": "OperationResultModel",
|
|
45720
|
-
"inputSchema": {
|
|
45721
|
-
"parentId": {
|
|
45722
|
-
"type": "string | number",
|
|
45723
|
-
"required": true,
|
|
45724
|
-
"description": "The parent record id (parent-scoped collection; number, or a canonical integer string)."
|
|
45725
|
-
},
|
|
45726
|
-
"id": {
|
|
45727
|
-
"type": "string | number",
|
|
45728
|
-
"required": true,
|
|
45729
|
-
"description": "The record id (number, or a canonical integer string — ids beyond 2^53 are supported via the string form)."
|
|
45730
|
-
},
|
|
45731
|
-
"data": {
|
|
45732
|
-
"type": "object",
|
|
45733
|
-
"required": true,
|
|
45734
|
-
"description": "The record payload (vendor model fields)."
|
|
45735
|
-
}
|
|
45736
|
-
},
|
|
45737
|
-
"inputSchemaStrict": true,
|
|
45738
|
-
"outputSchema": {
|
|
45739
|
-
"type": "OperationResultModel",
|
|
45740
|
-
"drops": []
|
|
45741
|
-
},
|
|
45742
|
-
"examples": [
|
|
45743
|
-
"await client.companyLocations.update('example-value', 'example-value', { name: 'example' }, { dryRun: true })"
|
|
45744
|
-
],
|
|
45745
|
-
"permissions": "unknown",
|
|
45746
|
-
"pagination": {
|
|
45747
|
-
"mode": "none"
|
|
45748
|
-
},
|
|
45749
|
-
"resolution": null,
|
|
45750
|
-
"retry": {
|
|
45751
|
-
"preset": "retry-85897a3a"
|
|
45752
|
-
},
|
|
45753
|
-
"errors": {
|
|
45754
|
-
"set": 1
|
|
45755
|
-
},
|
|
45756
|
-
"metadata": {
|
|
45757
|
-
"purpose": "Update a company location.",
|
|
45758
|
-
"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.",
|
|
45759
|
-
"preferredWhen": "Preferred over create or delete when the record exists and only some fields change.",
|
|
45760
|
-
"related": [
|
|
45761
|
-
"company_locations.get"
|
|
47066
|
+
"company_note_attachments.get"
|
|
45762
47067
|
],
|
|
47068
|
+
"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.",
|
|
45763
47069
|
"untrustedFields": [
|
|
45764
|
-
"
|
|
45765
|
-
"name"
|
|
47070
|
+
"title"
|
|
45766
47071
|
]
|
|
45767
47072
|
},
|
|
45768
47073
|
"compact": null,
|
|
@@ -48420,7 +49725,7 @@
|
|
|
48420
49725
|
"drops": []
|
|
48421
49726
|
},
|
|
48422
49727
|
"examples": [
|
|
48423
|
-
"await client.
|
|
49728
|
+
"await invoke(client, 'configuration_item_dns_records.count', [{ filter: [{ field: 'installedProductID', op: 'eq', value: 7 }] }])"
|
|
48424
49729
|
],
|
|
48425
49730
|
"permissions": "unknown",
|
|
48426
49731
|
"pagination": {
|
|
@@ -48796,7 +50101,7 @@
|
|
|
48796
50101
|
"drops": []
|
|
48797
50102
|
},
|
|
48798
50103
|
"examples": [
|
|
48799
|
-
"await client.
|
|
50104
|
+
"await invoke(client, 'configuration_item_dns_records.query', [{ filter: [{ field: 'installedProductID', op: 'eq', value: 7 }], limit: 500 }])"
|
|
48800
50105
|
],
|
|
48801
50106
|
"permissions": "unknown",
|
|
48802
50107
|
"pagination": {
|
|
@@ -48818,7 +50123,7 @@
|
|
|
48818
50123
|
},
|
|
48819
50124
|
"metadata": {
|
|
48820
50125
|
"purpose": "Query ConfigurationItemDnsRecord records with a JSON filter.",
|
|
48821
|
-
"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
|
|
50126
|
+
"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 installedProductID eq <parentId> where the parent is known). 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.",
|
|
48822
50127
|
"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).",
|
|
48823
50128
|
"related": [
|
|
48824
50129
|
"configuration_item_dns_records.resolve"
|
|
@@ -73100,6 +74405,516 @@
|
|
|
73100
74405
|
"compact": null,
|
|
73101
74406
|
"status": "tested"
|
|
73102
74407
|
},
|
|
74408
|
+
{
|
|
74409
|
+
"id": "task_notes.count",
|
|
74410
|
+
"resource": "task_notes",
|
|
74411
|
+
"udfCapable": false,
|
|
74412
|
+
"operation": "count",
|
|
74413
|
+
"kind": "primitive",
|
|
74414
|
+
"endpoint": "GET|POST /V1.0/TaskNotes/query/count",
|
|
74415
|
+
"effect": "read",
|
|
74416
|
+
"flags": [],
|
|
74417
|
+
"dryRun": false,
|
|
74418
|
+
"envelope": "QueryCountResultModel",
|
|
74419
|
+
"inputSchema": {
|
|
74420
|
+
"params": {
|
|
74421
|
+
"type": "object",
|
|
74422
|
+
"required": false,
|
|
74423
|
+
"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.",
|
|
74424
|
+
"properties": [
|
|
74425
|
+
{
|
|
74426
|
+
"name": "filter",
|
|
74427
|
+
"type": "FilterCondition[]",
|
|
74428
|
+
"optional": true
|
|
74429
|
+
},
|
|
74430
|
+
{
|
|
74431
|
+
"name": "fieldCheck",
|
|
74432
|
+
"type": "boolean",
|
|
74433
|
+
"optional": true
|
|
74434
|
+
}
|
|
74435
|
+
]
|
|
74436
|
+
}
|
|
74437
|
+
},
|
|
74438
|
+
"inputSchemaStrict": true,
|
|
74439
|
+
"outputSchema": {
|
|
74440
|
+
"type": "QueryCountResultModel",
|
|
74441
|
+
"drops": []
|
|
74442
|
+
},
|
|
74443
|
+
"examples": [
|
|
74444
|
+
"await invoke(client, 'task_notes.count', [{ filter: [{ field: 'taskID', op: 'eq', value: 7 }] }])"
|
|
74445
|
+
],
|
|
74446
|
+
"permissions": "unknown",
|
|
74447
|
+
"pagination": {
|
|
74448
|
+
"mode": "none"
|
|
74449
|
+
},
|
|
74450
|
+
"resolution": null,
|
|
74451
|
+
"retry": {
|
|
74452
|
+
"preset": "retry-ffb3a9cb"
|
|
74453
|
+
},
|
|
74454
|
+
"errors": {
|
|
74455
|
+
"set": 0
|
|
74456
|
+
},
|
|
74457
|
+
"metadata": {
|
|
74458
|
+
"purpose": "Count task note records matching a JSON filter.",
|
|
74459
|
+
"usage": "Unwraps queryCount; returns a plain number.",
|
|
74460
|
+
"preferredWhen": null,
|
|
74461
|
+
"related": [
|
|
74462
|
+
"task_notes.query"
|
|
74463
|
+
],
|
|
74464
|
+
"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.",
|
|
74465
|
+
"untrustedFields": [
|
|
74466
|
+
"description",
|
|
74467
|
+
"title"
|
|
74468
|
+
]
|
|
74469
|
+
},
|
|
74470
|
+
"compact": null,
|
|
74471
|
+
"status": "tested"
|
|
74472
|
+
},
|
|
74473
|
+
{
|
|
74474
|
+
"id": "task_notes.create",
|
|
74475
|
+
"resource": "task_notes",
|
|
74476
|
+
"udfCapable": false,
|
|
74477
|
+
"operation": "create",
|
|
74478
|
+
"kind": "primitive",
|
|
74479
|
+
"endpoint": "POST /V1.0/Tasks/{parentId}/Notes",
|
|
74480
|
+
"effect": "write",
|
|
74481
|
+
"flags": [],
|
|
74482
|
+
"dryRun": true,
|
|
74483
|
+
"envelope": "OperationResultModel",
|
|
74484
|
+
"inputSchema": {
|
|
74485
|
+
"parentId": {
|
|
74486
|
+
"type": "string | number",
|
|
74487
|
+
"required": true,
|
|
74488
|
+
"description": "The parent record id (parent-scoped collection; number, or a canonical integer string)."
|
|
74489
|
+
},
|
|
74490
|
+
"data": {
|
|
74491
|
+
"type": "object",
|
|
74492
|
+
"required": true,
|
|
74493
|
+
"description": "The record payload (vendor model fields)."
|
|
74494
|
+
}
|
|
74495
|
+
},
|
|
74496
|
+
"inputSchemaStrict": true,
|
|
74497
|
+
"outputSchema": {
|
|
74498
|
+
"type": "OperationResultModel",
|
|
74499
|
+
"drops": []
|
|
74500
|
+
},
|
|
74501
|
+
"examples": [
|
|
74502
|
+
"const fields = await client.taskNotes.getFieldInfo();\nconst activeValue = (name) => {\n const field = fields.find(field => field.name === name && field.isPickList === true);\n const choice = field?.picklistValues?.find(choice => choice.isActive === true && typeof choice.value === 'string' && /^-?\\d+$/.test(choice.value) && Number.isSafeInteger(Number(choice.value)));\n if (!choice) throw new Error(`No active integer picklist choice is available for ${name}; check TaskNotes field metadata.`);\n return Number(choice.value);\n};\nconst noteType = activeValue('noteType');\nconst publish = activeValue('publish');\nawait client.taskNotes.create(7, { description: 'Work completed', title: 'Progress', noteType, publish, taskID: 7 }, { dryRun: true });"
|
|
74503
|
+
],
|
|
74504
|
+
"permissions": "unknown",
|
|
74505
|
+
"pagination": {
|
|
74506
|
+
"mode": "none"
|
|
74507
|
+
},
|
|
74508
|
+
"resolution": null,
|
|
74509
|
+
"retry": {
|
|
74510
|
+
"preset": "retry-c5657094"
|
|
74511
|
+
},
|
|
74512
|
+
"errors": {
|
|
74513
|
+
"set": 1
|
|
74514
|
+
},
|
|
74515
|
+
"metadata": {
|
|
74516
|
+
"purpose": "Create a task note.",
|
|
74517
|
+
"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. Description writes use plain text and can lose existing rich text/images. The create body must include taskID equal to the parentId path argument; official documentation does not establish that the URL fills this required field. Current field metadata supplies picklist values; no numeric value is presumed valid. Baseline-project notes are read-only. Task Category settings may require title. Contact impersonation requires permission, publish ALL (resolve its value from current metadata), an active contact and account, and a task belonging to the contact's account or a child account. Writable fields: description (max 3200), title (max 250), noteType, publish, createdByContactID and matching taskID; creator/date fields and UDF writes are refused. Create requires description, noteType, publish and taskID.",
|
|
74518
|
+
"preferredWhen": "Only for a record that does not exist yet; prefer update for an id you already have.",
|
|
74519
|
+
"related": [
|
|
74520
|
+
"task_notes.update"
|
|
74521
|
+
],
|
|
74522
|
+
"deleteBoundary": {
|
|
74523
|
+
"resource": "task_notes",
|
|
74524
|
+
"note": "The vendor defines no DELETE for task_notes (spec-derived); a created task note cannot be removed through the public API.",
|
|
74525
|
+
"proof": "spec-derived"
|
|
74526
|
+
},
|
|
74527
|
+
"untrustedFields": [
|
|
74528
|
+
"description",
|
|
74529
|
+
"title"
|
|
74530
|
+
]
|
|
74531
|
+
},
|
|
74532
|
+
"compact": null,
|
|
74533
|
+
"status": "tested"
|
|
74534
|
+
},
|
|
74535
|
+
{
|
|
74536
|
+
"id": "task_notes.get",
|
|
74537
|
+
"resource": "task_notes",
|
|
74538
|
+
"udfCapable": false,
|
|
74539
|
+
"operation": "get",
|
|
74540
|
+
"kind": "primitive",
|
|
74541
|
+
"endpoint": "GET /V1.0/Tasks/{parentId}/Notes/{id}",
|
|
74542
|
+
"effect": "read",
|
|
74543
|
+
"flags": [],
|
|
74544
|
+
"dryRun": false,
|
|
74545
|
+
"envelope": "ItemQueryResultModel[TaskNoteModel,TaskNote]",
|
|
74546
|
+
"inputSchema": {
|
|
74547
|
+
"parentId": {
|
|
74548
|
+
"type": "string | number",
|
|
74549
|
+
"required": true,
|
|
74550
|
+
"description": "The parent record id (parent-scoped collection; number, or a canonical integer string)."
|
|
74551
|
+
},
|
|
74552
|
+
"id": {
|
|
74553
|
+
"type": "string | number",
|
|
74554
|
+
"required": true,
|
|
74555
|
+
"description": "The record id (number, or a canonical integer string — ids beyond 2^53 are supported via the string form)."
|
|
74556
|
+
},
|
|
74557
|
+
"opts": {
|
|
74558
|
+
"type": "object",
|
|
74559
|
+
"required": false,
|
|
74560
|
+
"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.",
|
|
74561
|
+
"properties": [
|
|
74562
|
+
{
|
|
74563
|
+
"name": "fresh",
|
|
74564
|
+
"type": "boolean",
|
|
74565
|
+
"optional": true
|
|
74566
|
+
}
|
|
74567
|
+
]
|
|
74568
|
+
}
|
|
74569
|
+
},
|
|
74570
|
+
"inputSchemaStrict": true,
|
|
74571
|
+
"outputSchema": {
|
|
74572
|
+
"type": "ItemQueryResultModel[TaskNoteModel,TaskNote]",
|
|
74573
|
+
"drops": []
|
|
74574
|
+
},
|
|
74575
|
+
"examples": [
|
|
74576
|
+
"await client.taskNotes.get(7, 3)"
|
|
74577
|
+
],
|
|
74578
|
+
"permissions": "unknown",
|
|
74579
|
+
"pagination": {
|
|
74580
|
+
"mode": "none"
|
|
74581
|
+
},
|
|
74582
|
+
"resolution": null,
|
|
74583
|
+
"retry": {
|
|
74584
|
+
"preset": "retry-ffb3a9cb"
|
|
74585
|
+
},
|
|
74586
|
+
"errors": {
|
|
74587
|
+
"set": 3
|
|
74588
|
+
},
|
|
74589
|
+
"metadata": {
|
|
74590
|
+
"purpose": "Get one TaskNote by id.",
|
|
74591
|
+
"usage": "item: null on the 200 body maps to NotFoundError (vendor not-found signal). Parent-scoped: parentId + id.",
|
|
74592
|
+
"preferredWhen": "Preferred when the parent task ID and note ID are known; use a bounded taskID-filtered query to discover notes.",
|
|
74593
|
+
"related": [],
|
|
74594
|
+
"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 a task_notes.query with includeFields.",
|
|
74595
|
+
"untrustedFields": [
|
|
74596
|
+
"description",
|
|
74597
|
+
"title"
|
|
74598
|
+
]
|
|
74599
|
+
},
|
|
74600
|
+
"compact": null,
|
|
74601
|
+
"status": "tested"
|
|
74602
|
+
},
|
|
74603
|
+
{
|
|
74604
|
+
"id": "task_notes.getEntityInfo",
|
|
74605
|
+
"resource": "task_notes",
|
|
74606
|
+
"udfCapable": false,
|
|
74607
|
+
"operation": "getEntityInfo",
|
|
74608
|
+
"kind": "primitive",
|
|
74609
|
+
"endpoint": "GET /V1.0/TaskNotes/entityInformation",
|
|
74610
|
+
"effect": "read",
|
|
74611
|
+
"flags": [],
|
|
74612
|
+
"dryRun": false,
|
|
74613
|
+
"envelope": "EntityInformationResultModel",
|
|
74614
|
+
"inputSchema": {},
|
|
74615
|
+
"inputSchemaStrict": true,
|
|
74616
|
+
"outputSchema": {
|
|
74617
|
+
"type": "EntityInformationResultModel",
|
|
74618
|
+
"drops": []
|
|
74619
|
+
},
|
|
74620
|
+
"examples": [
|
|
74621
|
+
"await client.taskNotes.getEntityInfo()"
|
|
74622
|
+
],
|
|
74623
|
+
"permissions": "unknown",
|
|
74624
|
+
"pagination": {
|
|
74625
|
+
"mode": "none"
|
|
74626
|
+
},
|
|
74627
|
+
"resolution": null,
|
|
74628
|
+
"retry": {
|
|
74629
|
+
"preset": "retry-ffb3a9cb"
|
|
74630
|
+
},
|
|
74631
|
+
"errors": {
|
|
74632
|
+
"set": 0
|
|
74633
|
+
},
|
|
74634
|
+
"metadata": {
|
|
74635
|
+
"purpose": "Get the TaskNote capability metadata (canCreate/canUpdate/hasUserDefinedFields/...).",
|
|
74636
|
+
"usage": "Unwraps info{}; drives client-side capability checks.",
|
|
74637
|
+
"preferredWhen": null,
|
|
74638
|
+
"related": [
|
|
74639
|
+
"task_notes.getFieldInfo"
|
|
74640
|
+
],
|
|
74641
|
+
"untrustedFields": [
|
|
74642
|
+
"description",
|
|
74643
|
+
"title"
|
|
74644
|
+
]
|
|
74645
|
+
},
|
|
74646
|
+
"compact": null,
|
|
74647
|
+
"status": "tested"
|
|
74648
|
+
},
|
|
74649
|
+
{
|
|
74650
|
+
"id": "task_notes.getFieldInfo",
|
|
74651
|
+
"resource": "task_notes",
|
|
74652
|
+
"udfCapable": false,
|
|
74653
|
+
"operation": "getFieldInfo",
|
|
74654
|
+
"kind": "primitive",
|
|
74655
|
+
"endpoint": "GET /V1.0/TaskNotes/entityInformation/fields",
|
|
74656
|
+
"effect": "read",
|
|
74657
|
+
"flags": [],
|
|
74658
|
+
"dryRun": false,
|
|
74659
|
+
"envelope": "FieldInformationResultModel",
|
|
74660
|
+
"inputSchema": {},
|
|
74661
|
+
"inputSchemaStrict": true,
|
|
74662
|
+
"outputSchema": {
|
|
74663
|
+
"type": "FieldInformationResultModel",
|
|
74664
|
+
"drops": []
|
|
74665
|
+
},
|
|
74666
|
+
"examples": [
|
|
74667
|
+
"await client.taskNotes.getFieldInfo()"
|
|
74668
|
+
],
|
|
74669
|
+
"permissions": "unknown",
|
|
74670
|
+
"pagination": {
|
|
74671
|
+
"mode": "none"
|
|
74672
|
+
},
|
|
74673
|
+
"resolution": null,
|
|
74674
|
+
"retry": {
|
|
74675
|
+
"preset": "retry-ffb3a9cb"
|
|
74676
|
+
},
|
|
74677
|
+
"errors": {
|
|
74678
|
+
"set": 0
|
|
74679
|
+
},
|
|
74680
|
+
"metadata": {
|
|
74681
|
+
"purpose": "Get the TaskNote field catalog (types, picklists, required, maxLength) — the full raw field dump (the largest read of the info trio; compact discovery: operations.fieldCatalog).",
|
|
74682
|
+
"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.",
|
|
74683
|
+
"preferredWhen": null,
|
|
74684
|
+
"related": [
|
|
74685
|
+
"task_notes.getEntityInfo",
|
|
74686
|
+
"task_notes.getUdfInfo"
|
|
74687
|
+
],
|
|
74688
|
+
"untrustedFields": [
|
|
74689
|
+
"description",
|
|
74690
|
+
"title"
|
|
74691
|
+
]
|
|
74692
|
+
},
|
|
74693
|
+
"compact": null,
|
|
74694
|
+
"status": "tested"
|
|
74695
|
+
},
|
|
74696
|
+
{
|
|
74697
|
+
"id": "task_notes.getUdfInfo",
|
|
74698
|
+
"resource": "task_notes",
|
|
74699
|
+
"udfCapable": false,
|
|
74700
|
+
"operation": "getUdfInfo",
|
|
74701
|
+
"kind": "primitive",
|
|
74702
|
+
"endpoint": "GET /V1.0/TaskNotes/entityInformation/userDefinedFields",
|
|
74703
|
+
"effect": "read",
|
|
74704
|
+
"flags": [],
|
|
74705
|
+
"dryRun": false,
|
|
74706
|
+
"envelope": "UserDefinedFieldInformationResultModel",
|
|
74707
|
+
"inputSchema": {},
|
|
74708
|
+
"inputSchemaStrict": true,
|
|
74709
|
+
"outputSchema": {
|
|
74710
|
+
"type": "UserDefinedFieldInformationResultModel",
|
|
74711
|
+
"drops": []
|
|
74712
|
+
},
|
|
74713
|
+
"examples": [
|
|
74714
|
+
"await client.taskNotes.getUdfInfo()"
|
|
74715
|
+
],
|
|
74716
|
+
"permissions": "unknown",
|
|
74717
|
+
"pagination": {
|
|
74718
|
+
"mode": "none"
|
|
74719
|
+
},
|
|
74720
|
+
"resolution": null,
|
|
74721
|
+
"retry": {
|
|
74722
|
+
"preset": "retry-ffb3a9cb"
|
|
74723
|
+
},
|
|
74724
|
+
"errors": {
|
|
74725
|
+
"set": 0
|
|
74726
|
+
},
|
|
74727
|
+
"metadata": {
|
|
74728
|
+
"purpose": "Get the TaskNote user-defined-field catalog.",
|
|
74729
|
+
"usage": "Unwraps fields[]; only meaningful where the entity is UDF-capable. (entity is not UDF-capable; catalog is expected empty).",
|
|
74730
|
+
"preferredWhen": null,
|
|
74731
|
+
"related": [
|
|
74732
|
+
"task_notes.getFieldInfo"
|
|
74733
|
+
],
|
|
74734
|
+
"untrustedFields": [
|
|
74735
|
+
"description",
|
|
74736
|
+
"title"
|
|
74737
|
+
]
|
|
74738
|
+
},
|
|
74739
|
+
"compact": null,
|
|
74740
|
+
"status": "tested"
|
|
74741
|
+
},
|
|
74742
|
+
{
|
|
74743
|
+
"id": "task_notes.query",
|
|
74744
|
+
"resource": "task_notes",
|
|
74745
|
+
"udfCapable": false,
|
|
74746
|
+
"operation": "query",
|
|
74747
|
+
"kind": "primitive",
|
|
74748
|
+
"endpoint": "GET|POST /V1.0/TaskNotes/query",
|
|
74749
|
+
"effect": "read",
|
|
74750
|
+
"flags": [],
|
|
74751
|
+
"dryRun": false,
|
|
74752
|
+
"envelope": "QueryActionResult[<Model>,<Entity>]",
|
|
74753
|
+
"inputSchema": {
|
|
74754
|
+
"params": {
|
|
74755
|
+
"type": "object",
|
|
74756
|
+
"required": false,
|
|
74757
|
+
"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.",
|
|
74758
|
+
"properties": [
|
|
74759
|
+
{
|
|
74760
|
+
"name": "filter",
|
|
74761
|
+
"type": "FilterCondition[]",
|
|
74762
|
+
"optional": true
|
|
74763
|
+
},
|
|
74764
|
+
{
|
|
74765
|
+
"name": "limit",
|
|
74766
|
+
"type": "number",
|
|
74767
|
+
"optional": true,
|
|
74768
|
+
"default": 500
|
|
74769
|
+
},
|
|
74770
|
+
{
|
|
74771
|
+
"name": "latest",
|
|
74772
|
+
"type": "number",
|
|
74773
|
+
"optional": true
|
|
74774
|
+
},
|
|
74775
|
+
{
|
|
74776
|
+
"name": "noteChars",
|
|
74777
|
+
"type": "number",
|
|
74778
|
+
"optional": true
|
|
74779
|
+
},
|
|
74780
|
+
{
|
|
74781
|
+
"name": "includeFields",
|
|
74782
|
+
"type": "string[]",
|
|
74783
|
+
"optional": true
|
|
74784
|
+
},
|
|
74785
|
+
{
|
|
74786
|
+
"name": "fieldCheck",
|
|
74787
|
+
"type": "boolean",
|
|
74788
|
+
"optional": true,
|
|
74789
|
+
"default": true
|
|
74790
|
+
},
|
|
74791
|
+
{
|
|
74792
|
+
"name": "names",
|
|
74793
|
+
"type": "boolean",
|
|
74794
|
+
"optional": true
|
|
74795
|
+
},
|
|
74796
|
+
{
|
|
74797
|
+
"name": "via",
|
|
74798
|
+
"type": "\"post\" | \"get\"",
|
|
74799
|
+
"optional": true
|
|
74800
|
+
},
|
|
74801
|
+
{
|
|
74802
|
+
"name": "acknowledgeUnscoped",
|
|
74803
|
+
"type": "boolean",
|
|
74804
|
+
"optional": true
|
|
74805
|
+
},
|
|
74806
|
+
{
|
|
74807
|
+
"name": "walk",
|
|
74808
|
+
"type": "object",
|
|
74809
|
+
"optional": true
|
|
74810
|
+
}
|
|
74811
|
+
]
|
|
74812
|
+
}
|
|
74813
|
+
},
|
|
74814
|
+
"inputSchemaStrict": true,
|
|
74815
|
+
"outputSchema": {
|
|
74816
|
+
"type": "QueryActionResult[<Model>,<Entity>]",
|
|
74817
|
+
"drops": []
|
|
74818
|
+
},
|
|
74819
|
+
"examples": [
|
|
74820
|
+
"await invoke(client, 'task_notes.query', [{ filter: [{ field: 'taskID', op: 'eq', value: 7 }], limit: 25 }])"
|
|
74821
|
+
],
|
|
74822
|
+
"permissions": "unknown",
|
|
74823
|
+
"pagination": {
|
|
74824
|
+
"mode": "cursor",
|
|
74825
|
+
"vendorDefault": 10,
|
|
74826
|
+
"vendorMax": 500,
|
|
74827
|
+
"pageGuard": 1000,
|
|
74828
|
+
"queryBounded": {
|
|
74829
|
+
"default": 500,
|
|
74830
|
+
"max": 2500
|
|
74831
|
+
}
|
|
74832
|
+
},
|
|
74833
|
+
"resolution": null,
|
|
74834
|
+
"retry": {
|
|
74835
|
+
"preset": "retry-ffb3a9cb"
|
|
74836
|
+
},
|
|
74837
|
+
"errors": {
|
|
74838
|
+
"set": 4
|
|
74839
|
+
},
|
|
74840
|
+
"metadata": {
|
|
74841
|
+
"purpose": "Query TaskNote records with a JSON filter.",
|
|
74842
|
+
"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 taskID eq <parentId> where the parent is known). 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.",
|
|
74843
|
+
"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).",
|
|
74844
|
+
"related": [],
|
|
74845
|
+
"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.",
|
|
74846
|
+
"untrustedFields": [
|
|
74847
|
+
"description",
|
|
74848
|
+
"title"
|
|
74849
|
+
]
|
|
74850
|
+
},
|
|
74851
|
+
"compact": null,
|
|
74852
|
+
"status": "tested"
|
|
74853
|
+
},
|
|
74854
|
+
{
|
|
74855
|
+
"id": "task_notes.update",
|
|
74856
|
+
"resource": "task_notes",
|
|
74857
|
+
"udfCapable": false,
|
|
74858
|
+
"operation": "update",
|
|
74859
|
+
"kind": "primitive",
|
|
74860
|
+
"endpoint": "PUT|PATCH /V1.0/Tasks/{parentId}/Notes",
|
|
74861
|
+
"effect": "write",
|
|
74862
|
+
"flags": [
|
|
74863
|
+
"idempotent"
|
|
74864
|
+
],
|
|
74865
|
+
"dryRun": true,
|
|
74866
|
+
"envelope": "OperationResultModel",
|
|
74867
|
+
"inputSchema": {
|
|
74868
|
+
"parentId": {
|
|
74869
|
+
"type": "string | number",
|
|
74870
|
+
"required": true,
|
|
74871
|
+
"description": "The parent record id (parent-scoped collection; number, or a canonical integer string)."
|
|
74872
|
+
},
|
|
74873
|
+
"id": {
|
|
74874
|
+
"type": "string | number",
|
|
74875
|
+
"required": true,
|
|
74876
|
+
"description": "The record id (number, or a canonical integer string — ids beyond 2^53 are supported via the string form)."
|
|
74877
|
+
},
|
|
74878
|
+
"data": {
|
|
74879
|
+
"type": "object",
|
|
74880
|
+
"required": true,
|
|
74881
|
+
"description": "The record payload (vendor model fields)."
|
|
74882
|
+
}
|
|
74883
|
+
},
|
|
74884
|
+
"inputSchemaStrict": true,
|
|
74885
|
+
"outputSchema": {
|
|
74886
|
+
"type": "OperationResultModel",
|
|
74887
|
+
"drops": []
|
|
74888
|
+
},
|
|
74889
|
+
"examples": [
|
|
74890
|
+
"await client.taskNotes.update(7, 3, { description: 'Updated progress' }, { dryRun: true })"
|
|
74891
|
+
],
|
|
74892
|
+
"permissions": "unknown",
|
|
74893
|
+
"pagination": {
|
|
74894
|
+
"mode": "none"
|
|
74895
|
+
},
|
|
74896
|
+
"resolution": null,
|
|
74897
|
+
"retry": {
|
|
74898
|
+
"preset": "retry-85897a3a"
|
|
74899
|
+
},
|
|
74900
|
+
"errors": {
|
|
74901
|
+
"set": 1
|
|
74902
|
+
},
|
|
74903
|
+
"metadata": {
|
|
74904
|
+
"purpose": "Update a task note.",
|
|
74905
|
+
"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). TaskNoteModel has no supported lastModifiedDate stale token; preview reads a fresh record, without promising an atomic vendor precondition. Parent-scoped: parentId + id. Description writes use plain text and can lose existing rich text/images. Parent taskID is the path argument; a supplied taskID must match. Current field metadata supplies picklist values; no numeric value is presumed valid. Baseline-project notes are read-only. Task Category settings may require title. Writable fields: description (max 3200), title (max 250), noteType, publish, createdByContactID and matching taskID; creator/date fields and UDF writes are refused.",
|
|
74906
|
+
"preferredWhen": "Use when an existing task note needs a supported field change.",
|
|
74907
|
+
"related": [
|
|
74908
|
+
"task_notes.get"
|
|
74909
|
+
],
|
|
74910
|
+
"untrustedFields": [
|
|
74911
|
+
"description",
|
|
74912
|
+
"title"
|
|
74913
|
+
]
|
|
74914
|
+
},
|
|
74915
|
+
"compact": null,
|
|
74916
|
+
"status": "tested"
|
|
74917
|
+
},
|
|
73103
74918
|
{
|
|
73104
74919
|
"id": "task_secondary_resources.count",
|
|
73105
74920
|
"resource": "task_secondary_resources",
|
|
@@ -82294,8 +84109,8 @@
|
|
|
82294
84109
|
]
|
|
82295
84110
|
},
|
|
82296
84111
|
"operations": {
|
|
82297
|
-
"planHash": "
|
|
82298
|
-
"builtAt": "2026-11-
|
|
84112
|
+
"planHash": "79f3968f072705fbc7b479dba6863a27bde47deee7b85885eda8d019302f9c25",
|
|
84113
|
+
"builtAt": "2026-11-18T13:26:09.224Z",
|
|
82299
84114
|
"records": [
|
|
82300
84115
|
{
|
|
82301
84116
|
"id": "operations.aggregate",
|