@shaclmate/shacl-ast 4.0.29 → 4.0.31

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (7) hide show
  1. package/dist/AbstractShapesGraph.d.ts +2 -2
  2. package/dist/AbstractShapesGraph.js +8 -8
  3. package/dist/ShapesGraph.d.ts +4 -4
  4. package/dist/ShapesGraph.js +4 -4
  5. package/dist/generated.d.ts +184 -250
  6. package/dist/generated.js +654 -711
  7. package/package.json +1 -1
package/dist/generated.d.ts CHANGED
@@ -2,6 +2,22 @@ import type { BlankNode, DatasetCore, Literal, NamedNode, Quad_Graph, Variable }
2
2
  import { PropertyPath as RdfxResourcePropertyPath, Resource, ResourceSet } from "@rdfx/resource";
3
3
  import { NTriplesTerm } from "@rdfx/string";
4
4
  import { Either, Maybe } from "purify-ts";
5
+ type $_FromRdfResourceFunction<T> = (resource: Resource, options: {
6
+ context: undefined | unknown;
7
+ graph: Exclude<Quad_Graph, Variable> | undefined;
8
+ ignoreRdfType: boolean;
9
+ objectSet: $ObjectSet;
10
+ preferredLanguages: readonly string[] | undefined;
11
+ }) => Either<Error, T>;
12
+ export type $_ToRdfResourceFunction<IdentifierT extends Resource.Identifier, ObjectT extends {
13
+ $identifier: () => IdentifierT;
14
+ }> = (parameters: {
15
+ graph: Exclude<Quad_Graph, Variable> | undefined;
16
+ ignoreRdfType: boolean;
17
+ object: ObjectT;
18
+ resource: Resource<IdentifierT>;
19
+ resourceSet: ResourceSet;
20
+ }) => void;
5
21
  interface $BooleanFilter {
6
22
  readonly value?: boolean;
7
23
  }
@@ -43,21 +59,14 @@ interface $NumericFilter<T> {
43
59
  readonly minExclusive?: T;
44
60
  readonly minInclusive?: T;
45
61
  }
46
- type $PropertiesFromRdfResourceFunction<T> = (resource: Resource, options: {
47
- context: undefined | unknown;
48
- graph: Exclude<Quad_Graph, Variable> | undefined;
49
- ignoreRdfType: boolean;
50
- objectSet: $ObjectSet;
51
- preferredLanguages?: readonly string[];
52
- }) => Either<Error, T>;
53
62
  export type $PropertyPath = RdfxResourcePropertyPath;
54
63
  export declare namespace $PropertyPath {
55
- type $Filter = object;
56
- function $filter(_filter: $Filter, _value: $PropertyPath): boolean;
57
- const $fromRdfResource: $FromRdfResourceFunction<$PropertyPath>;
58
- const $fromRdfResourceValues: $FromRdfResourceValuesFunction<$PropertyPath>;
59
- const $schema: Readonly<object>;
60
- const $toRdfResource: $ToRdfResourceFunction<$PropertyPath>;
64
+ type Filter = object;
65
+ function filter(_filter: Filter, _value: $PropertyPath): boolean;
66
+ const fromRdfResource: $FromRdfResourceFunction<$PropertyPath>;
67
+ const fromRdfResourceValues: $FromRdfResourceValuesFunction<$PropertyPath>;
68
+ const schema: Readonly<object>;
69
+ const toRdfResource: $ToRdfResourceFunction<$PropertyPath>;
61
70
  const $toString: typeof RdfxResourcePropertyPath.toString;
62
71
  }
63
72
  export interface $ShaclPropertySchema<TypeSchemaT = object> {
@@ -76,11 +85,11 @@ interface $TermFilter {
76
85
  readonly languageIn?: readonly string[];
77
86
  readonly typeIn?: readonly ("BlankNode" | "Literal" | "NamedNode")[];
78
87
  }
79
- export type $ToRdfResourceFunction<T> = (value: T, options?: {
88
+ export type $ToRdfResourceFunction<ObjectT, IdentifierT extends Resource.Identifier = Resource.Identifier> = (object: ObjectT, options?: {
80
89
  graph?: Exclude<Quad_Graph, Variable>;
81
90
  ignoreRdfType?: boolean;
82
91
  resourceSet?: ResourceSet;
83
- }) => Resource;
92
+ }) => Resource<IdentifierT>;
84
93
  export type $ToRdfResourceValuesFunction<ValueT, ReturnT extends BlankNode | Literal | NamedNode = BlankNode | Literal | NamedNode> = (value: ValueT, options: {
85
94
  graph?: Exclude<Quad_Graph, Variable>;
86
95
  ignoreRdfType?: boolean;
@@ -89,7 +98,7 @@ export type $ToRdfResourceValuesFunction<ValueT, ReturnT extends BlankNode | Lit
89
98
  resourceSet: ResourceSet;
90
99
  }) => ReturnT[];
91
100
  export interface PropertyShape {
92
- readonly $identifier: () => PropertyShape.$Identifier;
101
+ readonly $identifier: () => PropertyShape.Identifier;
93
102
  readonly $type: "PropertyShape";
94
103
  readonly and: Maybe<readonly (BlankNode | NamedNode)[]>;
95
104
  readonly classes: readonly NamedNode[];
@@ -125,8 +134,8 @@ export interface PropertyShape {
125
134
  readonly xone: Maybe<readonly (BlankNode | NamedNode)[]>;
126
135
  }
127
136
  export declare namespace PropertyShape {
128
- function $create(parameters: {
129
- readonly $identifier?: (() => PropertyShape.$Identifier) | (BlankNode | NamedNode) | string;
137
+ function create(parameters: {
138
+ readonly $identifier?: (() => PropertyShape.Identifier) | (BlankNode | NamedNode) | string;
130
139
  readonly and?: Maybe<readonly (BlankNode | NamedNode)[]> | readonly (BlankNode | NamedNode)[] | readonly string[];
131
140
  readonly classes?: readonly NamedNode[] | readonly string[];
132
141
  readonly comment?: Maybe<string> | string;
@@ -160,13 +169,13 @@ export declare namespace PropertyShape {
160
169
  readonly uniqueLang?: Maybe<boolean> | boolean;
161
170
  readonly xone?: Maybe<readonly (BlankNode | NamedNode)[]> | readonly (BlankNode | NamedNode)[] | readonly string[];
162
171
  }): PropertyShape;
163
- type $Identifier = BlankNode | NamedNode;
164
- namespace $Identifier {
172
+ type Identifier = BlankNode | NamedNode;
173
+ namespace Identifier {
165
174
  const parse: (value: string) => Either<Error, import("@rdfx/string/dist/Identifier.js").Identifier>;
166
175
  const stringify: typeof NTriplesTerm.stringify;
167
176
  }
168
- function $filter(filter: PropertyShape.$Filter, value: PropertyShape): boolean;
169
- type $Filter = {
177
+ function filter(filter: PropertyShape.Filter, value: PropertyShape): boolean;
178
+ type Filter = {
170
179
  readonly $identifier?: $IdentifierFilter;
171
180
  readonly and?: $MaybeFilter<$CollectionFilter<$IdentifierFilter>>;
172
181
  readonly classes?: $CollectionFilter<$IriFilter>;
@@ -196,52 +205,17 @@ export declare namespace PropertyShape {
196
205
  readonly not?: $CollectionFilter<$IdentifierFilter>;
197
206
  readonly or?: $MaybeFilter<$CollectionFilter<$IdentifierFilter>>;
198
207
  readonly order?: $MaybeFilter<$NumericFilter<number>>;
199
- readonly path?: $PropertyPath.$Filter;
208
+ readonly path?: $PropertyPath.Filter;
200
209
  readonly patterns?: $CollectionFilter<$StringFilter>;
201
210
  readonly uniqueLang?: $MaybeFilter<$BooleanFilter>;
202
211
  readonly xone?: $MaybeFilter<$CollectionFilter<$IdentifierFilter>>;
203
212
  };
204
- const $fromRdfResource: $FromRdfResourceFunction<PropertyShape>;
205
- const $fromRdfResourceValues: $FromRdfResourceValuesFunction<PropertyShape>;
206
- const $fromRdfType: NamedNode<string>;
213
+ const _fromRdfResource: $_FromRdfResourceFunction<PropertyShape>;
214
+ const fromRdfResource: $FromRdfResourceFunction<PropertyShape>;
215
+ const fromRdfResourceValues: $FromRdfResourceValuesFunction<PropertyShape>;
216
+ const fromRdfType: NamedNode<string>;
207
217
  function isPropertyShape(object: $Object): object is PropertyShape;
208
- const $propertiesFromRdfResource: $PropertiesFromRdfResourceFunction<{
209
- $identifier: BlankNode | NamedNode;
210
- $type: "PropertyShape";
211
- and: Maybe<readonly (BlankNode | NamedNode)[]>;
212
- classes: readonly NamedNode[];
213
- comment: Maybe<string>;
214
- datatype: Maybe<NamedNode>;
215
- deactivated: Maybe<boolean>;
216
- defaultValue: Maybe<NamedNode | Literal>;
217
- description: Maybe<string>;
218
- flags: readonly string[];
219
- groups: readonly (BlankNode | NamedNode)[];
220
- hasValues: readonly (NamedNode | Literal)[];
221
- in_: Maybe<readonly (NamedNode | Literal)[]>;
222
- isDefinedBy: Maybe<BlankNode | NamedNode>;
223
- label: Maybe<string>;
224
- languageIn: Maybe<readonly string[]>;
225
- maxCount: Maybe<bigint>;
226
- maxExclusive: Maybe<Literal>;
227
- maxInclusive: Maybe<Literal>;
228
- maxLength: Maybe<bigint>;
229
- minCount: Maybe<bigint>;
230
- minExclusive: Maybe<Literal>;
231
- minInclusive: Maybe<Literal>;
232
- minLength: Maybe<bigint>;
233
- name: Maybe<string>;
234
- node: Maybe<BlankNode | NamedNode>;
235
- nodeKind: Maybe<NamedNode<"http://www.w3.org/ns/shacl#BlankNode" | "http://www.w3.org/ns/shacl#BlankNodeOrIRI" | "http://www.w3.org/ns/shacl#BlankNodeOrLiteral" | "http://www.w3.org/ns/shacl#IRI" | "http://www.w3.org/ns/shacl#IRIOrLiteral" | "http://www.w3.org/ns/shacl#Literal">>;
236
- not: readonly (BlankNode | NamedNode)[];
237
- or: Maybe<readonly (BlankNode | NamedNode)[]>;
238
- order: Maybe<number>;
239
- path: $PropertyPath;
240
- patterns: readonly string[];
241
- uniqueLang: Maybe<boolean>;
242
- xone: Maybe<readonly (BlankNode | NamedNode)[]>;
243
- }>;
244
- const $schema: {
218
+ const schema: {
245
219
  readonly properties: {
246
220
  readonly $identifier: {
247
221
  readonly kind: "Identifier";
@@ -589,45 +563,41 @@ export declare namespace PropertyShape {
589
563
  };
590
564
  };
591
565
  };
592
- function $toRdfResource(_propertyShape: PropertyShape, options?: Parameters<$ToRdfResourceFunction<PropertyShape>>[1]): Resource;
593
- function $propertiesToStrings(_propertyShape: PropertyShape): Record<string, string>;
566
+ const _toRdfResource: $_ToRdfResourceFunction<PropertyShape.Identifier, PropertyShape>;
567
+ const toRdfResource: $ToRdfResourceFunction<PropertyShape, Identifier>;
568
+ function _propertiesToStrings(_propertyShape: PropertyShape): Record<string, string>;
594
569
  function $toString(this: PropertyShape): string;
595
570
  function $toString(_propertyShape: PropertyShape): string;
596
571
  }
597
572
  export interface PropertyGroup {
598
- readonly $identifier: () => PropertyGroup.$Identifier;
573
+ readonly $identifier: () => PropertyGroup.Identifier;
599
574
  readonly $type: "PropertyGroup";
600
575
  readonly comment: Maybe<string>;
601
576
  readonly label: Maybe<string>;
602
577
  }
603
578
  export declare namespace PropertyGroup {
604
- function $create(parameters?: {
605
- readonly $identifier?: (() => PropertyGroup.$Identifier) | (BlankNode | NamedNode) | string;
579
+ function create(parameters?: {
580
+ readonly $identifier?: (() => PropertyGroup.Identifier) | (BlankNode | NamedNode) | string;
606
581
  readonly comment?: Maybe<string> | string;
607
582
  readonly label?: Maybe<string> | string;
608
583
  }): PropertyGroup;
609
- type $Identifier = BlankNode | NamedNode;
610
- namespace $Identifier {
584
+ type Identifier = BlankNode | NamedNode;
585
+ namespace Identifier {
611
586
  const parse: (value: string) => Either<Error, import("@rdfx/string/dist/Identifier.js").Identifier>;
612
587
  const stringify: typeof NTriplesTerm.stringify;
613
588
  }
614
- function $filter(filter: PropertyGroup.$Filter, value: PropertyGroup): boolean;
615
- type $Filter = {
589
+ function filter(filter: PropertyGroup.Filter, value: PropertyGroup): boolean;
590
+ type Filter = {
616
591
  readonly $identifier?: $IdentifierFilter;
617
592
  readonly comment?: $MaybeFilter<$StringFilter>;
618
593
  readonly label?: $MaybeFilter<$StringFilter>;
619
594
  };
620
- const $fromRdfResource: $FromRdfResourceFunction<PropertyGroup>;
621
- const $fromRdfResourceValues: $FromRdfResourceValuesFunction<PropertyGroup>;
622
- const $fromRdfType: NamedNode<string>;
595
+ const _fromRdfResource: $_FromRdfResourceFunction<PropertyGroup>;
596
+ const fromRdfResource: $FromRdfResourceFunction<PropertyGroup>;
597
+ const fromRdfResourceValues: $FromRdfResourceValuesFunction<PropertyGroup>;
598
+ const fromRdfType: NamedNode<string>;
623
599
  function isPropertyGroup(object: $Object): object is PropertyGroup;
624
- const $propertiesFromRdfResource: $PropertiesFromRdfResourceFunction<{
625
- $identifier: BlankNode | NamedNode;
626
- $type: "PropertyGroup";
627
- comment: Maybe<string>;
628
- label: Maybe<string>;
629
- }>;
630
- const $schema: {
600
+ const schema: {
631
601
  readonly properties: {
632
602
  readonly $identifier: {
633
603
  readonly kind: "Identifier";
@@ -664,45 +634,41 @@ export declare namespace PropertyGroup {
664
634
  };
665
635
  };
666
636
  };
667
- function $toRdfResource(_propertyGroup: PropertyGroup, options?: Parameters<$ToRdfResourceFunction<PropertyGroup>>[1]): Resource;
668
- function $propertiesToStrings(_propertyGroup: PropertyGroup): Record<string, string>;
637
+ const _toRdfResource: $_ToRdfResourceFunction<PropertyGroup.Identifier, PropertyGroup>;
638
+ const toRdfResource: $ToRdfResourceFunction<PropertyGroup, Identifier>;
639
+ function _propertiesToStrings(_propertyGroup: PropertyGroup): Record<string, string>;
669
640
  function $toString(this: PropertyGroup): string;
670
641
  function $toString(_propertyGroup: PropertyGroup): string;
671
642
  }
672
643
  export interface Ontology {
673
- readonly $identifier: () => Ontology.$Identifier;
644
+ readonly $identifier: () => Ontology.Identifier;
674
645
  readonly $type: "Ontology";
675
646
  readonly comment: Maybe<string>;
676
647
  readonly label: Maybe<string>;
677
648
  }
678
649
  export declare namespace Ontology {
679
- function $create(parameters?: {
680
- readonly $identifier?: (() => Ontology.$Identifier) | (BlankNode | NamedNode) | string;
650
+ function create(parameters?: {
651
+ readonly $identifier?: (() => Ontology.Identifier) | (BlankNode | NamedNode) | string;
681
652
  readonly comment?: Maybe<string> | string;
682
653
  readonly label?: Maybe<string> | string;
683
654
  }): Ontology;
684
- type $Identifier = BlankNode | NamedNode;
685
- namespace $Identifier {
655
+ type Identifier = BlankNode | NamedNode;
656
+ namespace Identifier {
686
657
  const parse: (value: string) => Either<Error, import("@rdfx/string/dist/Identifier.js").Identifier>;
687
658
  const stringify: typeof NTriplesTerm.stringify;
688
659
  }
689
- function $filter(filter: Ontology.$Filter, value: Ontology): boolean;
690
- type $Filter = {
660
+ function filter(filter: Ontology.Filter, value: Ontology): boolean;
661
+ type Filter = {
691
662
  readonly $identifier?: $IdentifierFilter;
692
663
  readonly comment?: $MaybeFilter<$StringFilter>;
693
664
  readonly label?: $MaybeFilter<$StringFilter>;
694
665
  };
695
- const $fromRdfResource: $FromRdfResourceFunction<Ontology>;
696
- const $fromRdfResourceValues: $FromRdfResourceValuesFunction<Ontology>;
697
- const $fromRdfType: NamedNode<string>;
666
+ const _fromRdfResource: $_FromRdfResourceFunction<Ontology>;
667
+ const fromRdfResource: $FromRdfResourceFunction<Ontology>;
668
+ const fromRdfResourceValues: $FromRdfResourceValuesFunction<Ontology>;
669
+ const fromRdfType: NamedNode<string>;
698
670
  function isOntology(object: $Object): object is Ontology;
699
- const $propertiesFromRdfResource: $PropertiesFromRdfResourceFunction<{
700
- $identifier: BlankNode | NamedNode;
701
- $type: "Ontology";
702
- comment: Maybe<string>;
703
- label: Maybe<string>;
704
- }>;
705
- const $schema: {
671
+ const schema: {
706
672
  readonly properties: {
707
673
  readonly $identifier: {
708
674
  readonly kind: "Identifier";
@@ -739,13 +705,14 @@ export declare namespace Ontology {
739
705
  };
740
706
  };
741
707
  };
742
- function $toRdfResource(_ontology: Ontology, options?: Parameters<$ToRdfResourceFunction<Ontology>>[1]): Resource;
743
- function $propertiesToStrings(_ontology: Ontology): Record<string, string>;
708
+ const _toRdfResource: $_ToRdfResourceFunction<Ontology.Identifier, Ontology>;
709
+ const toRdfResource: $ToRdfResourceFunction<Ontology, Identifier>;
710
+ function _propertiesToStrings(_ontology: Ontology): Record<string, string>;
744
711
  function $toString(this: Ontology): string;
745
712
  function $toString(_ontology: Ontology): string;
746
713
  }
747
714
  export interface NodeShape {
748
- readonly $identifier: () => NodeShape.$Identifier;
715
+ readonly $identifier: () => NodeShape.Identifier;
749
716
  readonly $type: "NodeShape";
750
717
  readonly and: Maybe<readonly (BlankNode | NamedNode)[]>;
751
718
  readonly classes: readonly NamedNode[];
@@ -779,8 +746,8 @@ export interface NodeShape {
779
746
  readonly xone: Maybe<readonly (BlankNode | NamedNode)[]>;
780
747
  }
781
748
  export declare namespace NodeShape {
782
- function $create(parameters?: {
783
- readonly $identifier?: (() => NodeShape.$Identifier) | (BlankNode | NamedNode) | string;
749
+ function create(parameters?: {
750
+ readonly $identifier?: (() => NodeShape.Identifier) | (BlankNode | NamedNode) | string;
784
751
  readonly and?: Maybe<readonly (BlankNode | NamedNode)[]> | readonly (BlankNode | NamedNode)[] | readonly string[];
785
752
  readonly classes?: readonly NamedNode[] | readonly string[];
786
753
  readonly closed?: Maybe<boolean> | boolean;
@@ -812,13 +779,13 @@ export declare namespace NodeShape {
812
779
  readonly types?: readonly NamedNode[] | readonly string[];
813
780
  readonly xone?: Maybe<readonly (BlankNode | NamedNode)[]> | readonly (BlankNode | NamedNode)[] | readonly string[];
814
781
  }): NodeShape;
815
- type $Identifier = BlankNode | NamedNode;
816
- namespace $Identifier {
782
+ type Identifier = BlankNode | NamedNode;
783
+ namespace Identifier {
817
784
  const parse: (value: string) => Either<Error, import("@rdfx/string/dist/Identifier.js").Identifier>;
818
785
  const stringify: typeof NTriplesTerm.stringify;
819
786
  }
820
- function $filter(filter: NodeShape.$Filter, value: NodeShape): boolean;
821
- type $Filter = {
787
+ function filter(filter: NodeShape.Filter, value: NodeShape): boolean;
788
+ type Filter = {
822
789
  readonly $identifier?: $IdentifierFilter;
823
790
  readonly and?: $MaybeFilter<$CollectionFilter<$IdentifierFilter>>;
824
791
  readonly classes?: $CollectionFilter<$IriFilter>;
@@ -851,45 +818,12 @@ export declare namespace NodeShape {
851
818
  readonly types?: $CollectionFilter<$IriFilter>;
852
819
  readonly xone?: $MaybeFilter<$CollectionFilter<$IdentifierFilter>>;
853
820
  };
854
- const $fromRdfResource: $FromRdfResourceFunction<NodeShape>;
855
- const $fromRdfResourceValues: $FromRdfResourceValuesFunction<NodeShape>;
856
- const $fromRdfType: NamedNode<string>;
821
+ const _fromRdfResource: $_FromRdfResourceFunction<NodeShape>;
822
+ const fromRdfResource: $FromRdfResourceFunction<NodeShape>;
823
+ const fromRdfResourceValues: $FromRdfResourceValuesFunction<NodeShape>;
824
+ const fromRdfType: NamedNode<string>;
857
825
  function isNodeShape(object: $Object): object is NodeShape;
858
- const $propertiesFromRdfResource: $PropertiesFromRdfResourceFunction<{
859
- $identifier: BlankNode | NamedNode;
860
- $type: "NodeShape";
861
- and: Maybe<readonly (BlankNode | NamedNode)[]>;
862
- classes: readonly NamedNode[];
863
- closed: Maybe<boolean>;
864
- comment: Maybe<string>;
865
- datatype: Maybe<NamedNode>;
866
- deactivated: Maybe<boolean>;
867
- flags: readonly string[];
868
- hasValues: readonly (NamedNode | Literal)[];
869
- ignoredProperties: Maybe<readonly NamedNode[]>;
870
- in_: Maybe<readonly (NamedNode | Literal)[]>;
871
- isDefinedBy: Maybe<BlankNode | NamedNode>;
872
- label: Maybe<string>;
873
- languageIn: Maybe<readonly string[]>;
874
- maxCount: Maybe<bigint>;
875
- maxExclusive: Maybe<Literal>;
876
- maxInclusive: Maybe<Literal>;
877
- maxLength: Maybe<bigint>;
878
- minCount: Maybe<bigint>;
879
- minExclusive: Maybe<Literal>;
880
- minInclusive: Maybe<Literal>;
881
- minLength: Maybe<bigint>;
882
- node: Maybe<BlankNode | NamedNode>;
883
- nodeKind: Maybe<NamedNode<"http://www.w3.org/ns/shacl#BlankNode" | "http://www.w3.org/ns/shacl#BlankNodeOrIRI" | "http://www.w3.org/ns/shacl#BlankNodeOrLiteral" | "http://www.w3.org/ns/shacl#IRI" | "http://www.w3.org/ns/shacl#IRIOrLiteral" | "http://www.w3.org/ns/shacl#Literal">>;
884
- not: readonly (BlankNode | NamedNode)[];
885
- or: Maybe<readonly (BlankNode | NamedNode)[]>;
886
- patterns: readonly string[];
887
- properties: readonly (BlankNode | NamedNode)[];
888
- subClassOf: readonly NamedNode[];
889
- types: readonly NamedNode[];
890
- xone: Maybe<readonly (BlankNode | NamedNode)[]>;
891
- }>;
892
- const $schema: {
826
+ const schema: {
893
827
  readonly properties: {
894
828
  readonly $identifier: {
895
829
  readonly kind: "Identifier";
@@ -1225,29 +1159,32 @@ export declare namespace NodeShape {
1225
1159
  };
1226
1160
  };
1227
1161
  };
1228
- function $toRdfResource(_nodeShape: NodeShape, options?: Parameters<$ToRdfResourceFunction<NodeShape>>[1]): Resource;
1229
- function $propertiesToStrings(_nodeShape: NodeShape): Record<string, string>;
1162
+ const _toRdfResource: $_ToRdfResourceFunction<NodeShape.Identifier, NodeShape>;
1163
+ const toRdfResource: $ToRdfResourceFunction<NodeShape, Identifier>;
1164
+ function _propertiesToStrings(_nodeShape: NodeShape): Record<string, string>;
1230
1165
  function $toString(this: NodeShape): string;
1231
1166
  function $toString(_nodeShape: NodeShape): string;
1232
1167
  }
1233
1168
  export type Shape = NodeShape | PropertyShape;
1234
1169
  export declare namespace Shape {
1235
- const $filter: (filter: Shape.$Filter, value: Shape) => boolean;
1236
- type $Filter = {
1170
+ const $toString: (value: Shape) => string;
1171
+ const filter: (filter: Shape.Filter, value: Shape) => boolean;
1172
+ type Filter = {
1237
1173
  readonly $identifier?: $IdentifierFilter;
1238
1174
  readonly on?: {
1239
- readonly NodeShape?: NodeShape.$Filter;
1240
- readonly PropertyShape?: PropertyShape.$Filter;
1175
+ readonly NodeShape?: NodeShape.Filter;
1176
+ readonly PropertyShape?: PropertyShape.Filter;
1241
1177
  };
1242
1178
  };
1243
- const $fromRdfResource: $FromRdfResourceFunction<Shape>;
1244
- const $fromRdfResourceValues: $FromRdfResourceValuesFunction<Shape>;
1245
- type $Identifier = BlankNode | NamedNode;
1246
- namespace $Identifier {
1179
+ const fromRdfResource: $FromRdfResourceFunction<Shape>;
1180
+ const fromRdfResourceValues: $FromRdfResourceValuesFunction<Shape>;
1181
+ type Identifier = BlankNode | NamedNode;
1182
+ namespace Identifier {
1247
1183
  const parse: (value: string) => Either<Error, import("@rdfx/string/dist/Identifier.js").Identifier>;
1248
1184
  const stringify: typeof NTriplesTerm.stringify;
1249
1185
  }
1250
- const $schema: {
1186
+ function isShape(object: $Object): object is Shape;
1187
+ const schema: {
1251
1188
  readonly kind: "NamedObjectUnion";
1252
1189
  readonly members: {
1253
1190
  readonly NodeShape: {
@@ -2210,37 +2147,36 @@ export declare namespace Shape {
2210
2147
  };
2211
2148
  };
2212
2149
  };
2213
- const $toRdfResource: $ToRdfResourceFunction<Shape>;
2214
- const $toRdfResourceValues: (value: Shape, _options: {
2150
+ const toRdfResource: $ToRdfResourceFunction<Shape>;
2151
+ const toRdfResourceValues: (value: Shape, _options: {
2215
2152
  graph?: Exclude<Quad_Graph, Variable>;
2216
2153
  ignoreRdfType?: boolean;
2217
2154
  propertyPath: $PropertyPath;
2218
2155
  resource: Resource;
2219
2156
  resourceSet: ResourceSet;
2220
2157
  }) => (BlankNode | NamedNode)[];
2221
- const $toString: (value: Shape) => string;
2222
- function isShape(object: $Object): object is Shape;
2223
2158
  }
2224
2159
  export type $Object = NodeShape | Ontology | PropertyGroup | PropertyShape;
2225
2160
  export declare namespace $Object {
2226
- const $filter: (filter: $Object.$Filter, value: $Object) => boolean;
2227
- type $Filter = {
2161
+ const $toString: (value: $Object) => string;
2162
+ const filter: (filter: $Object.Filter, value: $Object) => boolean;
2163
+ type Filter = {
2228
2164
  readonly $identifier?: $IdentifierFilter;
2229
2165
  readonly on?: {
2230
- readonly NodeShape?: NodeShape.$Filter;
2231
- readonly Ontology?: Ontology.$Filter;
2232
- readonly PropertyGroup?: PropertyGroup.$Filter;
2233
- readonly PropertyShape?: PropertyShape.$Filter;
2166
+ readonly NodeShape?: NodeShape.Filter;
2167
+ readonly Ontology?: Ontology.Filter;
2168
+ readonly PropertyGroup?: PropertyGroup.Filter;
2169
+ readonly PropertyShape?: PropertyShape.Filter;
2234
2170
  };
2235
2171
  };
2236
- const $fromRdfResource: $FromRdfResourceFunction<$Object>;
2237
- const $fromRdfResourceValues: $FromRdfResourceValuesFunction<$Object>;
2238
- type $Identifier = BlankNode | NamedNode;
2239
- namespace $Identifier {
2172
+ const fromRdfResource: $FromRdfResourceFunction<$Object>;
2173
+ const fromRdfResourceValues: $FromRdfResourceValuesFunction<$Object>;
2174
+ type Identifier = BlankNode | NamedNode;
2175
+ namespace Identifier {
2240
2176
  const parse: (value: string) => Either<Error, import("@rdfx/string/dist/Identifier.js").Identifier>;
2241
2177
  const stringify: typeof NTriplesTerm.stringify;
2242
2178
  }
2243
- const $schema: {
2179
+ const schema: {
2244
2180
  readonly kind: "NamedObjectUnion";
2245
2181
  readonly members: {
2246
2182
  readonly NodeShape: {
@@ -3037,53 +2973,52 @@ export declare namespace $Object {
3037
2973
  };
3038
2974
  };
3039
2975
  };
3040
- const $toRdfResource: $ToRdfResourceFunction<$Object>;
3041
- const $toRdfResourceValues: (value: $Object, _options: {
2976
+ const toRdfResource: $ToRdfResourceFunction<$Object>;
2977
+ const toRdfResourceValues: (value: $Object, _options: {
3042
2978
  graph?: Exclude<Quad_Graph, Variable>;
3043
2979
  ignoreRdfType?: boolean;
3044
2980
  propertyPath: $PropertyPath;
3045
2981
  resource: Resource;
3046
2982
  resourceSet: ResourceSet;
3047
2983
  }) => (BlankNode | NamedNode)[];
3048
- const $toString: (value: $Object) => string;
3049
2984
  }
3050
2985
  export interface $ObjectSet {
3051
- nodeShape(identifier: NodeShape.$Identifier, options?: {
2986
+ nodeShape(identifier: NodeShape.Identifier, options?: {
3052
2987
  preferredLanguages?: readonly string[];
3053
2988
  }): Promise<Either<Error, NodeShape>>;
3054
- nodeShapeCount(query?: Pick<$ObjectSet.Query<NodeShape.$Filter, NodeShape.$Identifier>, "filter">): Promise<Either<Error, number>>;
3055
- nodeShapeIdentifiers(query?: $ObjectSet.Query<NodeShape.$Filter, NodeShape.$Identifier>): Promise<Either<Error, readonly NodeShape.$Identifier[]>>;
3056
- nodeShapes(query?: $ObjectSet.Query<NodeShape.$Filter, NodeShape.$Identifier>): Promise<Either<Error, readonly NodeShape[]>>;
3057
- ontology(identifier: Ontology.$Identifier, options?: {
2989
+ nodeShapeCount(query?: Pick<$ObjectSet.Query<NodeShape.Filter, NodeShape.Identifier>, "filter">): Promise<Either<Error, number>>;
2990
+ nodeShapeIdentifiers(query?: $ObjectSet.Query<NodeShape.Filter, NodeShape.Identifier>): Promise<Either<Error, readonly NodeShape.Identifier[]>>;
2991
+ nodeShapes(query?: $ObjectSet.Query<NodeShape.Filter, NodeShape.Identifier>): Promise<Either<Error, readonly NodeShape[]>>;
2992
+ ontology(identifier: Ontology.Identifier, options?: {
3058
2993
  preferredLanguages?: readonly string[];
3059
2994
  }): Promise<Either<Error, Ontology>>;
3060
- ontologyCount(query?: Pick<$ObjectSet.Query<Ontology.$Filter, Ontology.$Identifier>, "filter">): Promise<Either<Error, number>>;
3061
- ontologyIdentifiers(query?: $ObjectSet.Query<Ontology.$Filter, Ontology.$Identifier>): Promise<Either<Error, readonly Ontology.$Identifier[]>>;
3062
- ontologies(query?: $ObjectSet.Query<Ontology.$Filter, Ontology.$Identifier>): Promise<Either<Error, readonly Ontology[]>>;
3063
- propertyGroup(identifier: PropertyGroup.$Identifier, options?: {
2995
+ ontologyCount(query?: Pick<$ObjectSet.Query<Ontology.Filter, Ontology.Identifier>, "filter">): Promise<Either<Error, number>>;
2996
+ ontologyIdentifiers(query?: $ObjectSet.Query<Ontology.Filter, Ontology.Identifier>): Promise<Either<Error, readonly Ontology.Identifier[]>>;
2997
+ ontologies(query?: $ObjectSet.Query<Ontology.Filter, Ontology.Identifier>): Promise<Either<Error, readonly Ontology[]>>;
2998
+ propertyGroup(identifier: PropertyGroup.Identifier, options?: {
3064
2999
  preferredLanguages?: readonly string[];
3065
3000
  }): Promise<Either<Error, PropertyGroup>>;
3066
- propertyGroupCount(query?: Pick<$ObjectSet.Query<PropertyGroup.$Filter, PropertyGroup.$Identifier>, "filter">): Promise<Either<Error, number>>;
3067
- propertyGroupIdentifiers(query?: $ObjectSet.Query<PropertyGroup.$Filter, PropertyGroup.$Identifier>): Promise<Either<Error, readonly PropertyGroup.$Identifier[]>>;
3068
- propertyGroups(query?: $ObjectSet.Query<PropertyGroup.$Filter, PropertyGroup.$Identifier>): Promise<Either<Error, readonly PropertyGroup[]>>;
3069
- propertyShape(identifier: PropertyShape.$Identifier, options?: {
3001
+ propertyGroupCount(query?: Pick<$ObjectSet.Query<PropertyGroup.Filter, PropertyGroup.Identifier>, "filter">): Promise<Either<Error, number>>;
3002
+ propertyGroupIdentifiers(query?: $ObjectSet.Query<PropertyGroup.Filter, PropertyGroup.Identifier>): Promise<Either<Error, readonly PropertyGroup.Identifier[]>>;
3003
+ propertyGroups(query?: $ObjectSet.Query<PropertyGroup.Filter, PropertyGroup.Identifier>): Promise<Either<Error, readonly PropertyGroup[]>>;
3004
+ propertyShape(identifier: PropertyShape.Identifier, options?: {
3070
3005
  preferredLanguages?: readonly string[];
3071
3006
  }): Promise<Either<Error, PropertyShape>>;
3072
- propertyShapeCount(query?: Pick<$ObjectSet.Query<PropertyShape.$Filter, PropertyShape.$Identifier>, "filter">): Promise<Either<Error, number>>;
3073
- propertyShapeIdentifiers(query?: $ObjectSet.Query<PropertyShape.$Filter, PropertyShape.$Identifier>): Promise<Either<Error, readonly PropertyShape.$Identifier[]>>;
3074
- propertyShapes(query?: $ObjectSet.Query<PropertyShape.$Filter, PropertyShape.$Identifier>): Promise<Either<Error, readonly PropertyShape[]>>;
3075
- shape(identifier: Shape.$Identifier, options?: {
3007
+ propertyShapeCount(query?: Pick<$ObjectSet.Query<PropertyShape.Filter, PropertyShape.Identifier>, "filter">): Promise<Either<Error, number>>;
3008
+ propertyShapeIdentifiers(query?: $ObjectSet.Query<PropertyShape.Filter, PropertyShape.Identifier>): Promise<Either<Error, readonly PropertyShape.Identifier[]>>;
3009
+ propertyShapes(query?: $ObjectSet.Query<PropertyShape.Filter, PropertyShape.Identifier>): Promise<Either<Error, readonly PropertyShape[]>>;
3010
+ shape(identifier: Shape.Identifier, options?: {
3076
3011
  preferredLanguages?: readonly string[];
3077
3012
  }): Promise<Either<Error, Shape>>;
3078
- shapeCount(query?: Pick<$ObjectSet.Query<Shape.$Filter, Shape.$Identifier>, "filter">): Promise<Either<Error, number>>;
3079
- shapeIdentifiers(query?: $ObjectSet.Query<Shape.$Filter, Shape.$Identifier>): Promise<Either<Error, readonly Shape.$Identifier[]>>;
3080
- shapes(query?: $ObjectSet.Query<Shape.$Filter, Shape.$Identifier>): Promise<Either<Error, readonly Shape[]>>;
3081
- $object(identifier: $Object.$Identifier, options?: {
3013
+ shapeCount(query?: Pick<$ObjectSet.Query<Shape.Filter, Shape.Identifier>, "filter">): Promise<Either<Error, number>>;
3014
+ shapeIdentifiers(query?: $ObjectSet.Query<Shape.Filter, Shape.Identifier>): Promise<Either<Error, readonly Shape.Identifier[]>>;
3015
+ shapes(query?: $ObjectSet.Query<Shape.Filter, Shape.Identifier>): Promise<Either<Error, readonly Shape[]>>;
3016
+ $object(identifier: $Object.Identifier, options?: {
3082
3017
  preferredLanguages?: readonly string[];
3083
3018
  }): Promise<Either<Error, $Object>>;
3084
- $objectCount(query?: Pick<$ObjectSet.Query<$Object.$Filter, $Object.$Identifier>, "filter">): Promise<Either<Error, number>>;
3085
- $objectIdentifiers(query?: $ObjectSet.Query<$Object.$Filter, $Object.$Identifier>): Promise<Either<Error, readonly $Object.$Identifier[]>>;
3086
- $objects(query?: $ObjectSet.Query<$Object.$Filter, $Object.$Identifier>): Promise<Either<Error, readonly $Object[]>>;
3019
+ $objectCount(query?: Pick<$ObjectSet.Query<$Object.Filter, $Object.Identifier>, "filter">): Promise<Either<Error, number>>;
3020
+ $objectIdentifiers(query?: $ObjectSet.Query<$Object.Filter, $Object.Identifier>): Promise<Either<Error, readonly $Object.Identifier[]>>;
3021
+ $objects(query?: $ObjectSet.Query<$Object.Filter, $Object.Identifier>): Promise<Either<Error, readonly $Object[]>>;
3087
3022
  }
3088
3023
  export declare namespace $ObjectSet {
3089
3024
  interface Query<ObjectFilterT, ObjectIdentifierT extends BlankNode | NamedNode> {
@@ -3097,84 +3032,83 @@ export declare namespace $ObjectSet {
3097
3032
  }
3098
3033
  export declare class $RdfjsDatasetObjectSet implements $ObjectSet {
3099
3034
  #private;
3100
- protected readonly $graph?: Exclude<Quad_Graph, Variable>;
3101
3035
  constructor(dataset: DatasetCore | (() => DatasetCore), options?: {
3102
3036
  graph?: Exclude<Quad_Graph, Variable>;
3103
3037
  });
3104
3038
  protected $dataset(): DatasetCore;
3105
3039
  protected $resourceSet(): ResourceSet;
3106
- nodeShape(identifier: NodeShape.$Identifier, options?: {
3040
+ nodeShape(identifier: NodeShape.Identifier, options?: {
3107
3041
  preferredLanguages?: readonly string[];
3108
3042
  }): Promise<Either<Error, NodeShape>>;
3109
- nodeShapeSync(identifier: NodeShape.$Identifier, options?: {
3043
+ nodeShapeSync(identifier: NodeShape.Identifier, options?: {
3110
3044
  preferredLanguages?: readonly string[];
3111
3045
  }): Either<Error, NodeShape>;
3112
- nodeShapeCount(query?: Pick<$ObjectSet.Query<NodeShape.$Filter, NodeShape.$Identifier>, "filter">): Promise<Either<Error, number>>;
3113
- nodeShapeCountSync(query?: Pick<$ObjectSet.Query<NodeShape.$Filter, NodeShape.$Identifier>, "filter">): Either<Error, number>;
3114
- nodeShapeIdentifiers(query?: $ObjectSet.Query<NodeShape.$Filter, NodeShape.$Identifier>): Promise<Either<Error, readonly NodeShape.$Identifier[]>>;
3115
- nodeShapeIdentifiersSync(query?: $ObjectSet.Query<NodeShape.$Filter, NodeShape.$Identifier>): Either<Error, readonly NodeShape.$Identifier[]>;
3116
- nodeShapes(query?: $ObjectSet.Query<NodeShape.$Filter, NodeShape.$Identifier>): Promise<Either<Error, readonly NodeShape[]>>;
3117
- nodeShapesSync(query?: $ObjectSet.Query<NodeShape.$Filter, NodeShape.$Identifier>): Either<Error, readonly NodeShape[]>;
3118
- ontology(identifier: Ontology.$Identifier, options?: {
3046
+ nodeShapeCount(query?: Pick<$ObjectSet.Query<NodeShape.Filter, NodeShape.Identifier>, "filter">): Promise<Either<Error, number>>;
3047
+ nodeShapeCountSync(query?: Pick<$ObjectSet.Query<NodeShape.Filter, NodeShape.Identifier>, "filter">): Either<Error, number>;
3048
+ nodeShapeIdentifiers(query?: $ObjectSet.Query<NodeShape.Filter, NodeShape.Identifier>): Promise<Either<Error, readonly NodeShape.Identifier[]>>;
3049
+ nodeShapeIdentifiersSync(query?: $ObjectSet.Query<NodeShape.Filter, NodeShape.Identifier>): Either<Error, readonly NodeShape.Identifier[]>;
3050
+ nodeShapes(query?: $ObjectSet.Query<NodeShape.Filter, NodeShape.Identifier>): Promise<Either<Error, readonly NodeShape[]>>;
3051
+ nodeShapesSync(query?: $ObjectSet.Query<NodeShape.Filter, NodeShape.Identifier>): Either<Error, readonly NodeShape[]>;
3052
+ ontology(identifier: Ontology.Identifier, options?: {
3119
3053
  preferredLanguages?: readonly string[];
3120
3054
  }): Promise<Either<Error, Ontology>>;
3121
- ontologySync(identifier: Ontology.$Identifier, options?: {
3055
+ ontologySync(identifier: Ontology.Identifier, options?: {
3122
3056
  preferredLanguages?: readonly string[];
3123
3057
  }): Either<Error, Ontology>;
3124
- ontologyCount(query?: Pick<$ObjectSet.Query<Ontology.$Filter, Ontology.$Identifier>, "filter">): Promise<Either<Error, number>>;
3125
- ontologyCountSync(query?: Pick<$ObjectSet.Query<Ontology.$Filter, Ontology.$Identifier>, "filter">): Either<Error, number>;
3126
- ontologyIdentifiers(query?: $ObjectSet.Query<Ontology.$Filter, Ontology.$Identifier>): Promise<Either<Error, readonly Ontology.$Identifier[]>>;
3127
- ontologyIdentifiersSync(query?: $ObjectSet.Query<Ontology.$Filter, Ontology.$Identifier>): Either<Error, readonly Ontology.$Identifier[]>;
3128
- ontologies(query?: $ObjectSet.Query<Ontology.$Filter, Ontology.$Identifier>): Promise<Either<Error, readonly Ontology[]>>;
3129
- ontologiesSync(query?: $ObjectSet.Query<Ontology.$Filter, Ontology.$Identifier>): Either<Error, readonly Ontology[]>;
3130
- propertyGroup(identifier: PropertyGroup.$Identifier, options?: {
3058
+ ontologyCount(query?: Pick<$ObjectSet.Query<Ontology.Filter, Ontology.Identifier>, "filter">): Promise<Either<Error, number>>;
3059
+ ontologyCountSync(query?: Pick<$ObjectSet.Query<Ontology.Filter, Ontology.Identifier>, "filter">): Either<Error, number>;
3060
+ ontologyIdentifiers(query?: $ObjectSet.Query<Ontology.Filter, Ontology.Identifier>): Promise<Either<Error, readonly Ontology.Identifier[]>>;
3061
+ ontologyIdentifiersSync(query?: $ObjectSet.Query<Ontology.Filter, Ontology.Identifier>): Either<Error, readonly Ontology.Identifier[]>;
3062
+ ontologies(query?: $ObjectSet.Query<Ontology.Filter, Ontology.Identifier>): Promise<Either<Error, readonly Ontology[]>>;
3063
+ ontologiesSync(query?: $ObjectSet.Query<Ontology.Filter, Ontology.Identifier>): Either<Error, readonly Ontology[]>;
3064
+ propertyGroup(identifier: PropertyGroup.Identifier, options?: {
3131
3065
  preferredLanguages?: readonly string[];
3132
3066
  }): Promise<Either<Error, PropertyGroup>>;
3133
- propertyGroupSync(identifier: PropertyGroup.$Identifier, options?: {
3067
+ propertyGroupSync(identifier: PropertyGroup.Identifier, options?: {
3134
3068
  preferredLanguages?: readonly string[];
3135
3069
  }): Either<Error, PropertyGroup>;
3136
- propertyGroupCount(query?: Pick<$ObjectSet.Query<PropertyGroup.$Filter, PropertyGroup.$Identifier>, "filter">): Promise<Either<Error, number>>;
3137
- propertyGroupCountSync(query?: Pick<$ObjectSet.Query<PropertyGroup.$Filter, PropertyGroup.$Identifier>, "filter">): Either<Error, number>;
3138
- propertyGroupIdentifiers(query?: $ObjectSet.Query<PropertyGroup.$Filter, PropertyGroup.$Identifier>): Promise<Either<Error, readonly PropertyGroup.$Identifier[]>>;
3139
- propertyGroupIdentifiersSync(query?: $ObjectSet.Query<PropertyGroup.$Filter, PropertyGroup.$Identifier>): Either<Error, readonly PropertyGroup.$Identifier[]>;
3140
- propertyGroups(query?: $ObjectSet.Query<PropertyGroup.$Filter, PropertyGroup.$Identifier>): Promise<Either<Error, readonly PropertyGroup[]>>;
3141
- propertyGroupsSync(query?: $ObjectSet.Query<PropertyGroup.$Filter, PropertyGroup.$Identifier>): Either<Error, readonly PropertyGroup[]>;
3142
- propertyShape(identifier: PropertyShape.$Identifier, options?: {
3070
+ propertyGroupCount(query?: Pick<$ObjectSet.Query<PropertyGroup.Filter, PropertyGroup.Identifier>, "filter">): Promise<Either<Error, number>>;
3071
+ propertyGroupCountSync(query?: Pick<$ObjectSet.Query<PropertyGroup.Filter, PropertyGroup.Identifier>, "filter">): Either<Error, number>;
3072
+ propertyGroupIdentifiers(query?: $ObjectSet.Query<PropertyGroup.Filter, PropertyGroup.Identifier>): Promise<Either<Error, readonly PropertyGroup.Identifier[]>>;
3073
+ propertyGroupIdentifiersSync(query?: $ObjectSet.Query<PropertyGroup.Filter, PropertyGroup.Identifier>): Either<Error, readonly PropertyGroup.Identifier[]>;
3074
+ propertyGroups(query?: $ObjectSet.Query<PropertyGroup.Filter, PropertyGroup.Identifier>): Promise<Either<Error, readonly PropertyGroup[]>>;
3075
+ propertyGroupsSync(query?: $ObjectSet.Query<PropertyGroup.Filter, PropertyGroup.Identifier>): Either<Error, readonly PropertyGroup[]>;
3076
+ propertyShape(identifier: PropertyShape.Identifier, options?: {
3143
3077
  preferredLanguages?: readonly string[];
3144
3078
  }): Promise<Either<Error, PropertyShape>>;
3145
- propertyShapeSync(identifier: PropertyShape.$Identifier, options?: {
3079
+ propertyShapeSync(identifier: PropertyShape.Identifier, options?: {
3146
3080
  preferredLanguages?: readonly string[];
3147
3081
  }): Either<Error, PropertyShape>;
3148
- propertyShapeCount(query?: Pick<$ObjectSet.Query<PropertyShape.$Filter, PropertyShape.$Identifier>, "filter">): Promise<Either<Error, number>>;
3149
- propertyShapeCountSync(query?: Pick<$ObjectSet.Query<PropertyShape.$Filter, PropertyShape.$Identifier>, "filter">): Either<Error, number>;
3150
- propertyShapeIdentifiers(query?: $ObjectSet.Query<PropertyShape.$Filter, PropertyShape.$Identifier>): Promise<Either<Error, readonly PropertyShape.$Identifier[]>>;
3151
- propertyShapeIdentifiersSync(query?: $ObjectSet.Query<PropertyShape.$Filter, PropertyShape.$Identifier>): Either<Error, readonly PropertyShape.$Identifier[]>;
3152
- propertyShapes(query?: $ObjectSet.Query<PropertyShape.$Filter, PropertyShape.$Identifier>): Promise<Either<Error, readonly PropertyShape[]>>;
3153
- propertyShapesSync(query?: $ObjectSet.Query<PropertyShape.$Filter, PropertyShape.$Identifier>): Either<Error, readonly PropertyShape[]>;
3154
- shape(identifier: Shape.$Identifier, options?: {
3082
+ propertyShapeCount(query?: Pick<$ObjectSet.Query<PropertyShape.Filter, PropertyShape.Identifier>, "filter">): Promise<Either<Error, number>>;
3083
+ propertyShapeCountSync(query?: Pick<$ObjectSet.Query<PropertyShape.Filter, PropertyShape.Identifier>, "filter">): Either<Error, number>;
3084
+ propertyShapeIdentifiers(query?: $ObjectSet.Query<PropertyShape.Filter, PropertyShape.Identifier>): Promise<Either<Error, readonly PropertyShape.Identifier[]>>;
3085
+ propertyShapeIdentifiersSync(query?: $ObjectSet.Query<PropertyShape.Filter, PropertyShape.Identifier>): Either<Error, readonly PropertyShape.Identifier[]>;
3086
+ propertyShapes(query?: $ObjectSet.Query<PropertyShape.Filter, PropertyShape.Identifier>): Promise<Either<Error, readonly PropertyShape[]>>;
3087
+ propertyShapesSync(query?: $ObjectSet.Query<PropertyShape.Filter, PropertyShape.Identifier>): Either<Error, readonly PropertyShape[]>;
3088
+ shape(identifier: Shape.Identifier, options?: {
3155
3089
  preferredLanguages?: readonly string[];
3156
3090
  }): Promise<Either<Error, Shape>>;
3157
- shapeSync(identifier: Shape.$Identifier, options?: {
3091
+ shapeSync(identifier: Shape.Identifier, options?: {
3158
3092
  preferredLanguages?: readonly string[];
3159
3093
  }): Either<Error, Shape>;
3160
- shapeCount(query?: Pick<$ObjectSet.Query<Shape.$Filter, Shape.$Identifier>, "filter">): Promise<Either<Error, number>>;
3161
- shapeCountSync(query?: Pick<$ObjectSet.Query<Shape.$Filter, Shape.$Identifier>, "filter">): Either<Error, number>;
3162
- shapeIdentifiers(query?: $ObjectSet.Query<Shape.$Filter, Shape.$Identifier>): Promise<Either<Error, readonly Shape.$Identifier[]>>;
3163
- shapeIdentifiersSync(query?: $ObjectSet.Query<Shape.$Filter, Shape.$Identifier>): Either<Error, readonly Shape.$Identifier[]>;
3164
- shapes(query?: $ObjectSet.Query<Shape.$Filter, Shape.$Identifier>): Promise<Either<Error, readonly Shape[]>>;
3165
- shapesSync(query?: $ObjectSet.Query<Shape.$Filter, Shape.$Identifier>): Either<Error, readonly Shape[]>;
3166
- $object(identifier: $Object.$Identifier, options?: {
3094
+ shapeCount(query?: Pick<$ObjectSet.Query<Shape.Filter, Shape.Identifier>, "filter">): Promise<Either<Error, number>>;
3095
+ shapeCountSync(query?: Pick<$ObjectSet.Query<Shape.Filter, Shape.Identifier>, "filter">): Either<Error, number>;
3096
+ shapeIdentifiers(query?: $ObjectSet.Query<Shape.Filter, Shape.Identifier>): Promise<Either<Error, readonly Shape.Identifier[]>>;
3097
+ shapeIdentifiersSync(query?: $ObjectSet.Query<Shape.Filter, Shape.Identifier>): Either<Error, readonly Shape.Identifier[]>;
3098
+ shapes(query?: $ObjectSet.Query<Shape.Filter, Shape.Identifier>): Promise<Either<Error, readonly Shape[]>>;
3099
+ shapesSync(query?: $ObjectSet.Query<Shape.Filter, Shape.Identifier>): Either<Error, readonly Shape[]>;
3100
+ $object(identifier: $Object.Identifier, options?: {
3167
3101
  preferredLanguages?: readonly string[];
3168
3102
  }): Promise<Either<Error, $Object>>;
3169
- $objectSync(identifier: $Object.$Identifier, options?: {
3103
+ $objectSync(identifier: $Object.Identifier, options?: {
3170
3104
  preferredLanguages?: readonly string[];
3171
3105
  }): Either<Error, $Object>;
3172
- $objectCount(query?: Pick<$ObjectSet.Query<$Object.$Filter, $Object.$Identifier>, "filter">): Promise<Either<Error, number>>;
3173
- $objectCountSync(query?: Pick<$ObjectSet.Query<$Object.$Filter, $Object.$Identifier>, "filter">): Either<Error, number>;
3174
- $objectIdentifiers(query?: $ObjectSet.Query<$Object.$Filter, $Object.$Identifier>): Promise<Either<Error, readonly $Object.$Identifier[]>>;
3175
- $objectIdentifiersSync(query?: $ObjectSet.Query<$Object.$Filter, $Object.$Identifier>): Either<Error, readonly $Object.$Identifier[]>;
3176
- $objects(query?: $ObjectSet.Query<$Object.$Filter, $Object.$Identifier>): Promise<Either<Error, readonly $Object[]>>;
3177
- $objectsSync(query?: $ObjectSet.Query<$Object.$Filter, $Object.$Identifier>): Either<Error, readonly $Object[]>;
3106
+ $objectCount(query?: Pick<$ObjectSet.Query<$Object.Filter, $Object.Identifier>, "filter">): Promise<Either<Error, number>>;
3107
+ $objectCountSync(query?: Pick<$ObjectSet.Query<$Object.Filter, $Object.Identifier>, "filter">): Either<Error, number>;
3108
+ $objectIdentifiers(query?: $ObjectSet.Query<$Object.Filter, $Object.Identifier>): Promise<Either<Error, readonly $Object.Identifier[]>>;
3109
+ $objectIdentifiersSync(query?: $ObjectSet.Query<$Object.Filter, $Object.Identifier>): Either<Error, readonly $Object.Identifier[]>;
3110
+ $objects(query?: $ObjectSet.Query<$Object.Filter, $Object.Identifier>): Promise<Either<Error, readonly $Object[]>>;
3111
+ $objectsSync(query?: $ObjectSet.Query<$Object.Filter, $Object.Identifier>): Either<Error, readonly $Object[]>;
3178
3112
  }
3179
3113
  export {};
3180
3114
  //# sourceMappingURL=generated.d.ts.map