@trylimbo/sdk-issuer 0.2.25-canary.37 → 0.2.25
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/gen/ffi/index.d.ts +730 -646
- package/gen/ffi/index.js +887 -794
- package/gen/grpc/buf/validate/validate_pb.d.ts +24 -30
- package/gen/grpc/buf/validate/validate_pb.js +2 -2
- package/gen/grpc/trylimbo/signer/v2/signer_pb.d.ts +799 -659
- package/gen/grpc/trylimbo/signer/v2/signer_pb.js +185 -175
- package/gen/grpc/trylimbo/version/v1/version_pb.d.ts +59 -0
- package/gen/grpc/trylimbo/version/v1/version_pb.js +32 -0
- package/package.json +3 -3
package/gen/ffi/index.js
CHANGED
|
@@ -935,6 +935,7 @@ function makePrimitive(read, write, byteSize) {
|
|
|
935
935
|
writeIntoCursor: write
|
|
936
936
|
};
|
|
937
937
|
}
|
|
938
|
+
const FfiConverterInt64 = makePrimitive((c) => c.readI64(), (v, c) => c.writeI64(v), 8);
|
|
938
939
|
const FfiConverterUInt8 = makePrimitive((c) => c.readU8(), (v, c) => c.writeU8(v), 1);
|
|
939
940
|
const FfiConverterUInt32 = makePrimitive((c) => c.readU32(), (v, c) => c.writeU32(v), 4);
|
|
940
941
|
const FfiConverterUInt64 = makePrimitive((c) => c.readU64(), (v, c) => c.writeU64(v), 8);
|
|
@@ -949,7 +950,7 @@ const FfiConverterBool = (() => {
|
|
|
949
950
|
writeIntoCursor: write
|
|
950
951
|
};
|
|
951
952
|
})();
|
|
952
|
-
|
|
953
|
+
(() => {
|
|
953
954
|
const msPerSecBigInt = BigInt("1000");
|
|
954
955
|
const nanosPerMs = 1e6;
|
|
955
956
|
class FFIConverter extends AbstractFfiConverterByteArray {
|
|
@@ -973,7 +974,7 @@ const FfiConverterDuration = (() => {
|
|
|
973
974
|
}
|
|
974
975
|
return new FFIConverter();
|
|
975
976
|
})();
|
|
976
|
-
|
|
977
|
+
(() => {
|
|
977
978
|
const msPerSecBigInt = BigInt("1000");
|
|
978
979
|
const nanosPerMs = 1e6;
|
|
979
980
|
const msPerSec = 1e3;
|
|
@@ -1174,13 +1175,6 @@ var FfiConverterCallback = class {
|
|
|
1174
1175
|
return this.handleMap.remove(handle);
|
|
1175
1176
|
}
|
|
1176
1177
|
};
|
|
1177
|
-
function uniffiTraitInterfaceCall(makeCall, handleSuccess, handleError, lowerString, alloc) {
|
|
1178
|
-
try {
|
|
1179
|
-
handleSuccess(makeCall());
|
|
1180
|
-
} catch (e) {
|
|
1181
|
-
handleError(2, lowerString(e.toString(), alloc));
|
|
1182
|
-
}
|
|
1183
|
-
}
|
|
1184
1178
|
function uniffiTraitInterfaceCallWithError(makeCall, handleSuccess, handleError, isErrorType, lowerError, lowerString, alloc) {
|
|
1185
1179
|
try {
|
|
1186
1180
|
handleSuccess(makeCall());
|
|
@@ -1623,12 +1617,12 @@ const DEFINITIONS = {
|
|
|
1623
1617
|
ret: FfiType.Void,
|
|
1624
1618
|
hasRustCallStatus: true
|
|
1625
1619
|
},
|
|
1626
|
-
"
|
|
1620
|
+
"uniffi_trylimbo_sdk_issuer_fn_clone_binder": {
|
|
1627
1621
|
args: [FfiType.Handle],
|
|
1628
1622
|
ret: FfiType.Handle,
|
|
1629
1623
|
hasRustCallStatus: true
|
|
1630
1624
|
},
|
|
1631
|
-
"
|
|
1625
|
+
"uniffi_trylimbo_sdk_issuer_fn_free_binder": {
|
|
1632
1626
|
args: [FfiType.Handle],
|
|
1633
1627
|
ret: FfiType.Void,
|
|
1634
1628
|
hasRustCallStatus: true
|
|
@@ -1653,6 +1647,26 @@ const DEFINITIONS = {
|
|
|
1653
1647
|
ret: FfiType.Void,
|
|
1654
1648
|
hasRustCallStatus: true
|
|
1655
1649
|
},
|
|
1650
|
+
"uniffi_trylimbo_sdk_issuer_fn_clone_heldbinder": {
|
|
1651
|
+
args: [FfiType.Handle],
|
|
1652
|
+
ret: FfiType.Handle,
|
|
1653
|
+
hasRustCallStatus: true
|
|
1654
|
+
},
|
|
1655
|
+
"uniffi_trylimbo_sdk_issuer_fn_free_heldbinder": {
|
|
1656
|
+
args: [FfiType.Handle],
|
|
1657
|
+
ret: FfiType.Void,
|
|
1658
|
+
hasRustCallStatus: true
|
|
1659
|
+
},
|
|
1660
|
+
"uniffi_trylimbo_sdk_issuer_fn_clone_isccbinder": {
|
|
1661
|
+
args: [FfiType.Handle],
|
|
1662
|
+
ret: FfiType.Handle,
|
|
1663
|
+
hasRustCallStatus: true
|
|
1664
|
+
},
|
|
1665
|
+
"uniffi_trylimbo_sdk_issuer_fn_free_isccbinder": {
|
|
1666
|
+
args: [FfiType.Handle],
|
|
1667
|
+
ret: FfiType.Void,
|
|
1668
|
+
hasRustCallStatus: true
|
|
1669
|
+
},
|
|
1656
1670
|
"uniffi_trylimbo_sdk_issuer_fn_clone_memorysink": {
|
|
1657
1671
|
args: [FfiType.Handle],
|
|
1658
1672
|
ret: FfiType.Handle,
|
|
@@ -1723,8 +1737,8 @@ const DEFINITIONS = {
|
|
|
1723
1737
|
ret: FfiType.Void,
|
|
1724
1738
|
hasRustCallStatus: true
|
|
1725
1739
|
},
|
|
1726
|
-
"
|
|
1727
|
-
args: [FfiType.Reference(FfiType.Struct("
|
|
1740
|
+
"uniffi_trylimbo_sdk_issuer_fn_init_callback_vtable_binder": {
|
|
1741
|
+
args: [FfiType.Reference(FfiType.Struct("VTableCallbackInterfaceTrylimboIssuerBinder"))],
|
|
1728
1742
|
ret: FfiType.Void,
|
|
1729
1743
|
hasRustCallStatus: false
|
|
1730
1744
|
},
|
|
@@ -1753,15 +1767,6 @@ const DEFINITIONS = {
|
|
|
1753
1767
|
ret: FfiType.Handle,
|
|
1754
1768
|
hasRustCallStatus: false
|
|
1755
1769
|
},
|
|
1756
|
-
"uniffi_trylimbo_sdk_issuer_fn_func_compute_soft_binding": {
|
|
1757
|
-
args: [
|
|
1758
|
-
FfiType.RustBuffer,
|
|
1759
|
-
FfiType.Handle,
|
|
1760
|
-
FfiType.RustBuffer
|
|
1761
|
-
],
|
|
1762
|
-
ret: FfiType.Handle,
|
|
1763
|
-
hasRustCallStatus: false
|
|
1764
|
-
},
|
|
1765
1770
|
"uniffi_trylimbo_sdk_issuer_fn_func_embed": {
|
|
1766
1771
|
args: [
|
|
1767
1772
|
FfiType.Handle,
|
|
@@ -1795,7 +1800,6 @@ const DEFINITIONS = {
|
|
|
1795
1800
|
},
|
|
1796
1801
|
"uniffi_trylimbo_sdk_issuer_fn_method_assetmarker_mark": {
|
|
1797
1802
|
args: [
|
|
1798
|
-
FfiType.Handle,
|
|
1799
1803
|
FfiType.Handle,
|
|
1800
1804
|
FfiType.Handle,
|
|
1801
1805
|
FfiType.RustBuffer
|
|
@@ -1803,13 +1807,12 @@ const DEFINITIONS = {
|
|
|
1803
1807
|
ret: FfiType.Handle,
|
|
1804
1808
|
hasRustCallStatus: false
|
|
1805
1809
|
},
|
|
1806
|
-
"
|
|
1807
|
-
args: [
|
|
1808
|
-
|
|
1809
|
-
|
|
1810
|
-
|
|
1811
|
-
|
|
1812
|
-
args: [FfiType.Handle, FfiType.RustBuffer],
|
|
1810
|
+
"uniffi_trylimbo_sdk_issuer_fn_method_binder_derive": {
|
|
1811
|
+
args: [
|
|
1812
|
+
FfiType.Handle,
|
|
1813
|
+
FfiType.Handle,
|
|
1814
|
+
FfiType.RustBuffer
|
|
1815
|
+
],
|
|
1813
1816
|
ret: FfiType.Handle,
|
|
1814
1817
|
hasRustCallStatus: false
|
|
1815
1818
|
},
|
|
@@ -1870,6 +1873,34 @@ const DEFINITIONS = {
|
|
|
1870
1873
|
ret: FfiType.Handle,
|
|
1871
1874
|
hasRustCallStatus: false
|
|
1872
1875
|
},
|
|
1876
|
+
"uniffi_trylimbo_sdk_issuer_fn_constructor_heldbinder_new": {
|
|
1877
|
+
args: [FfiType.RustBuffer],
|
|
1878
|
+
ret: FfiType.Handle,
|
|
1879
|
+
hasRustCallStatus: true
|
|
1880
|
+
},
|
|
1881
|
+
"uniffi_trylimbo_sdk_issuer_fn_method_heldbinder_derive": {
|
|
1882
|
+
args: [
|
|
1883
|
+
FfiType.Handle,
|
|
1884
|
+
FfiType.Handle,
|
|
1885
|
+
FfiType.RustBuffer
|
|
1886
|
+
],
|
|
1887
|
+
ret: FfiType.Handle,
|
|
1888
|
+
hasRustCallStatus: false
|
|
1889
|
+
},
|
|
1890
|
+
"uniffi_trylimbo_sdk_issuer_fn_constructor_isccbinder_new": {
|
|
1891
|
+
args: [],
|
|
1892
|
+
ret: FfiType.Handle,
|
|
1893
|
+
hasRustCallStatus: true
|
|
1894
|
+
},
|
|
1895
|
+
"uniffi_trylimbo_sdk_issuer_fn_method_isccbinder_derive": {
|
|
1896
|
+
args: [
|
|
1897
|
+
FfiType.Handle,
|
|
1898
|
+
FfiType.Handle,
|
|
1899
|
+
FfiType.RustBuffer
|
|
1900
|
+
],
|
|
1901
|
+
ret: FfiType.Handle,
|
|
1902
|
+
hasRustCallStatus: false
|
|
1903
|
+
},
|
|
1873
1904
|
"uniffi_trylimbo_sdk_issuer_fn_constructor_memorysink_new": {
|
|
1874
1905
|
args: [FfiType.RustBuffer],
|
|
1875
1906
|
ret: FfiType.Handle,
|
|
@@ -2021,11 +2052,6 @@ const DEFINITIONS = {
|
|
|
2021
2052
|
ret: FfiType.UInt16,
|
|
2022
2053
|
hasRustCallStatus: false
|
|
2023
2054
|
},
|
|
2024
|
-
"uniffi_trylimbo_sdk_issuer_checksum_func_compute_soft_binding": {
|
|
2025
|
-
args: [],
|
|
2026
|
-
ret: FfiType.UInt16,
|
|
2027
|
-
hasRustCallStatus: false
|
|
2028
|
-
},
|
|
2029
2055
|
"uniffi_trylimbo_sdk_issuer_checksum_func_embed": {
|
|
2030
2056
|
args: [],
|
|
2031
2057
|
ret: FfiType.UInt16,
|
|
@@ -2051,12 +2077,7 @@ const DEFINITIONS = {
|
|
|
2051
2077
|
ret: FfiType.UInt16,
|
|
2052
2078
|
hasRustCallStatus: false
|
|
2053
2079
|
},
|
|
2054
|
-
"
|
|
2055
|
-
args: [],
|
|
2056
|
-
ret: FfiType.UInt16,
|
|
2057
|
-
hasRustCallStatus: false
|
|
2058
|
-
},
|
|
2059
|
-
"uniffi_trylimbo_sdk_issuer_checksum_method_compute_compute": {
|
|
2080
|
+
"uniffi_trylimbo_sdk_issuer_checksum_method_binder_derive": {
|
|
2060
2081
|
args: [],
|
|
2061
2082
|
ret: FfiType.UInt16,
|
|
2062
2083
|
hasRustCallStatus: false
|
|
@@ -2106,6 +2127,26 @@ const DEFINITIONS = {
|
|
|
2106
2127
|
ret: FfiType.UInt16,
|
|
2107
2128
|
hasRustCallStatus: false
|
|
2108
2129
|
},
|
|
2130
|
+
"uniffi_trylimbo_sdk_issuer_checksum_constructor_heldbinder_new": {
|
|
2131
|
+
args: [],
|
|
2132
|
+
ret: FfiType.UInt16,
|
|
2133
|
+
hasRustCallStatus: false
|
|
2134
|
+
},
|
|
2135
|
+
"uniffi_trylimbo_sdk_issuer_checksum_method_heldbinder_derive": {
|
|
2136
|
+
args: [],
|
|
2137
|
+
ret: FfiType.UInt16,
|
|
2138
|
+
hasRustCallStatus: false
|
|
2139
|
+
},
|
|
2140
|
+
"uniffi_trylimbo_sdk_issuer_checksum_constructor_isccbinder_new": {
|
|
2141
|
+
args: [],
|
|
2142
|
+
ret: FfiType.UInt16,
|
|
2143
|
+
hasRustCallStatus: false
|
|
2144
|
+
},
|
|
2145
|
+
"uniffi_trylimbo_sdk_issuer_checksum_method_isccbinder_derive": {
|
|
2146
|
+
args: [],
|
|
2147
|
+
ret: FfiType.UInt16,
|
|
2148
|
+
hasRustCallStatus: false
|
|
2149
|
+
},
|
|
2109
2150
|
"uniffi_trylimbo_sdk_issuer_checksum_constructor_memorysink_new": {
|
|
2110
2151
|
args: [],
|
|
2111
2152
|
ret: FfiType.UInt16,
|
|
@@ -2223,19 +2264,14 @@ const DEFINITIONS = {
|
|
|
2223
2264
|
ret: FfiType.Void,
|
|
2224
2265
|
hasRustCallStatus: false
|
|
2225
2266
|
},
|
|
2226
|
-
"CallbackInterfaceTrylimboIssuerComputeMethod0": {
|
|
2227
|
-
args: [FfiType.Handle],
|
|
2228
|
-
ret: FfiType.RustBuffer,
|
|
2229
|
-
hasRustCallStatus: true,
|
|
2230
|
-
outReturn: true
|
|
2231
|
-
},
|
|
2232
2267
|
"ForeignFutureCompleterust_buffer": {
|
|
2233
2268
|
args: [FfiType.Handle, FfiType.Struct("ForeignFutureResultRustBuffer")],
|
|
2234
2269
|
ret: FfiType.Void,
|
|
2235
2270
|
hasRustCallStatus: false
|
|
2236
2271
|
},
|
|
2237
|
-
"
|
|
2272
|
+
"CallbackInterfaceTrylimboIssuerBinderMethod0": {
|
|
2238
2273
|
args: [
|
|
2274
|
+
FfiType.Handle,
|
|
2239
2275
|
FfiType.Handle,
|
|
2240
2276
|
FfiType.RustBuffer,
|
|
2241
2277
|
FfiType.Callback("ForeignFutureCompleterust_buffer"),
|
|
@@ -2245,12 +2281,12 @@ const DEFINITIONS = {
|
|
|
2245
2281
|
hasRustCallStatus: false,
|
|
2246
2282
|
outReturn: true
|
|
2247
2283
|
},
|
|
2248
|
-
"
|
|
2284
|
+
"CallbackInterfaceCloneTrylimboIssuer_Binder": {
|
|
2249
2285
|
args: [FfiType.Handle],
|
|
2250
2286
|
ret: FfiType.Handle,
|
|
2251
2287
|
hasRustCallStatus: false
|
|
2252
2288
|
},
|
|
2253
|
-
"
|
|
2289
|
+
"CallbackInterfaceFreeTrylimboIssuer_Binder": {
|
|
2254
2290
|
args: [FfiType.Handle],
|
|
2255
2291
|
ret: FfiType.Void,
|
|
2256
2292
|
hasRustCallStatus: false
|
|
@@ -2405,7 +2441,7 @@ const DEFINITIONS = {
|
|
|
2405
2441
|
"CallbackInterfaceTrylimboIssuerSigningVaultMethod0": {
|
|
2406
2442
|
args: [
|
|
2407
2443
|
FfiType.Handle,
|
|
2408
|
-
FfiType.
|
|
2444
|
+
FfiType.UInt64,
|
|
2409
2445
|
FfiType.Callback("ForeignFutureCompleterust_buffer"),
|
|
2410
2446
|
FfiType.Handle
|
|
2411
2447
|
],
|
|
@@ -2462,22 +2498,18 @@ const DEFINITIONS = {
|
|
|
2462
2498
|
name: "call_status",
|
|
2463
2499
|
type: FfiType.RustCallStatus
|
|
2464
2500
|
}],
|
|
2465
|
-
"
|
|
2501
|
+
"VTableCallbackInterfaceTrylimboIssuerBinder": [
|
|
2466
2502
|
{
|
|
2467
2503
|
name: "uniffi_free",
|
|
2468
|
-
type: FfiType.Callback("
|
|
2504
|
+
type: FfiType.Callback("CallbackInterfaceFreeTrylimboIssuer_Binder")
|
|
2469
2505
|
},
|
|
2470
2506
|
{
|
|
2471
2507
|
name: "uniffi_clone",
|
|
2472
|
-
type: FfiType.Callback("
|
|
2473
|
-
},
|
|
2474
|
-
{
|
|
2475
|
-
name: "alg",
|
|
2476
|
-
type: FfiType.Callback("CallbackInterfaceTrylimboIssuerComputeMethod0")
|
|
2508
|
+
type: FfiType.Callback("CallbackInterfaceCloneTrylimboIssuer_Binder")
|
|
2477
2509
|
},
|
|
2478
2510
|
{
|
|
2479
|
-
name: "
|
|
2480
|
-
type: FfiType.Callback("
|
|
2511
|
+
name: "derive",
|
|
2512
|
+
type: FfiType.Callback("CallbackInterfaceTrylimboIssuerBinderMethod0")
|
|
2481
2513
|
}
|
|
2482
2514
|
],
|
|
2483
2515
|
"ForeignFutureResultU64": [{
|
|
@@ -2609,77 +2641,75 @@ var trylimbo_issuer_exports = /* @__PURE__ */ __exportAll({
|
|
|
2609
2641
|
Assertion: () => Assertion,
|
|
2610
2642
|
AssetDelivery: () => AssetDelivery,
|
|
2611
2643
|
AssetDelivery_Tags: () => AssetDelivery_Tags,
|
|
2644
|
+
AssetFormat: () => AssetFormat,
|
|
2645
|
+
AssetFormat_Tags: () => AssetFormat_Tags,
|
|
2612
2646
|
AssetIssuer: () => AssetIssuer,
|
|
2613
2647
|
AssetManifestSpec: () => AssetManifestSpec,
|
|
2614
2648
|
AssetMarker: () => AssetMarker,
|
|
2615
2649
|
AssetOrigin: () => AssetOrigin,
|
|
2616
2650
|
AssetOrigin_Tags: () => AssetOrigin_Tags,
|
|
2617
|
-
|
|
2618
|
-
ByteRange: () => ByteRange,
|
|
2651
|
+
BinderImpl: () => BinderImpl,
|
|
2619
2652
|
Code: () => Code,
|
|
2620
2653
|
Component: () => Component,
|
|
2621
2654
|
ComponentEvent: () => ComponentEvent,
|
|
2622
2655
|
ComponentEvent_Tags: () => ComponentEvent_Tags,
|
|
2623
|
-
ComputeImpl: () => ComputeImpl,
|
|
2624
|
-
ComputeRequest: () => ComputeRequest,
|
|
2625
2656
|
ConnectOptions: () => ConnectOptions,
|
|
2626
2657
|
CreatedOrigin: () => CreatedOrigin,
|
|
2627
2658
|
CustomAction: () => CustomAction,
|
|
2659
|
+
DeriveOptions: () => DeriveOptions,
|
|
2628
2660
|
EmbedOptions: () => EmbedOptions,
|
|
2629
2661
|
FieldViolation: () => FieldViolation,
|
|
2630
2662
|
FileSink: () => FileSink,
|
|
2631
2663
|
FileSource: () => FileSource,
|
|
2664
|
+
HeldBinder: () => HeldBinder,
|
|
2632
2665
|
Identity: () => Identity,
|
|
2633
2666
|
Ingredient: () => Ingredient,
|
|
2634
|
-
|
|
2635
|
-
|
|
2667
|
+
IngredientSource: () => IngredientSource,
|
|
2668
|
+
IngredientSource_Tags: () => IngredientSource_Tags,
|
|
2636
2669
|
InitOptions: () => InitOptions,
|
|
2637
2670
|
InitOutcome: () => InitOutcome,
|
|
2671
|
+
IsccBinder: () => IsccBinder,
|
|
2638
2672
|
MarkOptions: () => MarkOptions,
|
|
2639
2673
|
MarkOutcome: () => MarkOutcome,
|
|
2640
2674
|
MemorySink: () => MemorySink,
|
|
2641
2675
|
MemorySource: () => MemorySource,
|
|
2642
|
-
MintRequest: () => MintRequest,
|
|
2643
2676
|
OpenedOrigin: () => OpenedOrigin,
|
|
2677
|
+
Origin: () => Origin,
|
|
2678
|
+
Origin_Tags: () => Origin_Tags,
|
|
2644
2679
|
RangeSinkImpl: () => RangeSinkImpl,
|
|
2645
2680
|
RangeSourceImpl: () => RangeSourceImpl,
|
|
2681
|
+
Region: () => Region,
|
|
2646
2682
|
RotationPolicy: () => RotationPolicy,
|
|
2647
|
-
Scope: () => Scope,
|
|
2648
2683
|
SdkError: () => SdkError,
|
|
2649
2684
|
SdkError_Tags: () => SdkError_Tags,
|
|
2650
2685
|
SegmentKind: () => SegmentKind,
|
|
2651
2686
|
SegmentOutcome: () => SegmentOutcome,
|
|
2652
|
-
SessionKey: () => SessionKey,
|
|
2653
2687
|
SignOptions: () => SignOptions,
|
|
2654
2688
|
SignOutcome: () => SignOutcome,
|
|
2655
2689
|
SignOutput: () => SignOutput,
|
|
2656
2690
|
SignOutput_Tags: () => SignOutput_Tags,
|
|
2657
2691
|
SignerClient: () => SignerClient,
|
|
2658
2692
|
SoftBinding: () => SoftBinding,
|
|
2659
|
-
SoftBindingSource: () => SoftBindingSource,
|
|
2660
|
-
SoftBindingSource_Tags: () => SoftBindingSource_Tags,
|
|
2661
|
-
SoftwareAgent: () => SoftwareAgent,
|
|
2662
2693
|
StandardAction: () => StandardAction,
|
|
2663
2694
|
StreamDelivery: () => StreamDelivery,
|
|
2695
|
+
StreamDelivery_Tags: () => StreamDelivery_Tags,
|
|
2664
2696
|
StreamIssuer: () => StreamIssuer,
|
|
2665
2697
|
StreamManifestSpec: () => StreamManifestSpec,
|
|
2666
|
-
StreamOrigin: () => StreamOrigin,
|
|
2667
|
-
StreamOrigin_Tags: () => StreamOrigin_Tags,
|
|
2668
2698
|
StreamSession: () => StreamSession,
|
|
2669
2699
|
StreamStart: () => StreamStart,
|
|
2670
2700
|
Thumbnail: () => Thumbnail,
|
|
2671
|
-
|
|
2701
|
+
VaultPublicKey: () => VaultPublicKey,
|
|
2672
2702
|
classifySegment: () => classifySegment,
|
|
2673
|
-
computeSoftBinding: () => computeSoftBinding,
|
|
2674
2703
|
default: () => trylimbo_issuer_default,
|
|
2675
2704
|
embed: () => embed
|
|
2676
2705
|
});
|
|
2677
2706
|
const uniffiCaller = new UniffiRustCaller(() => ({ code: 0 }));
|
|
2678
2707
|
const uniffiIsDebug = typeof process !== "object" || process?.env?.NODE_ENV !== "production" || false;
|
|
2679
2708
|
/**
|
|
2680
|
-
* Classify a fragmented-MP4 segment
|
|
2681
|
-
*
|
|
2682
|
-
*
|
|
2709
|
+
* Classify a fragmented-MP4 segment from a [`RangeSource`] as init/media/unknown: the
|
|
2710
|
+
* SDK-owned box parse (`moov` vs `moof`) a streaming consumer uses to route each segment
|
|
2711
|
+
* to [`StreamIssuer::init`](stream::StreamIssuer::init) vs
|
|
2712
|
+
* [`StreamSession::sign`](stream::StreamSession::sign) without hand-parsing ISOBMFF itself.
|
|
2683
2713
|
*
|
|
2684
2714
|
* Async because it reads, and reading is the caller's storage: the two windows below may each
|
|
2685
2715
|
* be a round trip. It stays off the island, uniquely among the read-path entry points, because
|
|
@@ -2708,36 +2738,22 @@ async function classifySegment(source, asyncOpts_) {
|
|
|
2708
2738
|
}
|
|
2709
2739
|
}
|
|
2710
2740
|
/**
|
|
2711
|
-
*
|
|
2712
|
-
* the
|
|
2741
|
+
* Embed a signed manifest into an asset, writing the composed result back through
|
|
2742
|
+
* `sink`. `plugins` are the caller's plugins for non-c2pa formats (e.g. MXF), in dispatch
|
|
2743
|
+
* order, resolved the same way [`AssetIssuer::sign`](asset::AssetIssuer::sign) resolves
|
|
2744
|
+
* them, per [the `plugins` contract](crate::asset#the-plugins-contract): the write lands on a
|
|
2745
|
+
* bounded region for a plugin match, on the whole (small) asset otherwise; an empty list is
|
|
2746
|
+
* a c2pa-native embed. `format` overrides the sniffed format. Pure local byte-wrangling: no
|
|
2747
|
+
* signer round-trip.
|
|
2713
2748
|
*
|
|
2714
|
-
* #
|
|
2749
|
+
* # Why the body is offloaded rather than run inline
|
|
2715
2750
|
*
|
|
2716
|
-
*
|
|
2717
|
-
*
|
|
2718
|
-
|
|
2719
|
-
|
|
2720
|
-
|
|
2721
|
-
|
|
2722
|
-
return await uniffiRustCallAsync(uniffiCaller, () => {
|
|
2723
|
-
return getter().uniffi_trylimbo_sdk_issuer_fn_func_compute_soft_binding(FfiConverterString.lower(alg, getter().rustbuffer_alloc), FfiConverterTypeRangeSource.lower(source, getter().rustbuffer_alloc), FfiConverterOptionalString.lower(format, getter().rustbuffer_alloc));
|
|
2724
|
-
}, getter().ffi_trylimbo_sdk_issuer_rust_future_poll_rust_buffer, getter().ffi_trylimbo_sdk_issuer_rust_future_cancel_rust_buffer, getter().ffi_trylimbo_sdk_issuer_rust_future_complete_rust_buffer, getter().ffi_trylimbo_sdk_issuer_rust_future_free_rust_buffer, (__rb) => {
|
|
2725
|
-
try {
|
|
2726
|
-
return FfiConverterSequenceTypeBlock.lift(__rb);
|
|
2727
|
-
} finally {
|
|
2728
|
-
getter().rustbuffer_free(__rb);
|
|
2729
|
-
}
|
|
2730
|
-
}, FfiConverterString.lift.bind(FfiConverterString), asyncOpts_, FfiConverterTypeSdkError.lift.bind(FfiConverterTypeSdkError));
|
|
2731
|
-
} catch (__error) {
|
|
2732
|
-
if (uniffiIsDebug && __error instanceof Error) __error.stack = __stack;
|
|
2733
|
-
throw __error;
|
|
2734
|
-
}
|
|
2735
|
-
}
|
|
2736
|
-
/**
|
|
2737
|
-
* Embed `sidecar`, the signed manifest a sign returned, into the asset `sink` holds, writing the
|
|
2738
|
-
* composed result back through `sink`.
|
|
2739
|
-
* `plugins` resolve a non-c2pa format (e.g. MXF) as `AssetIssuer.sign` resolves them; none is a
|
|
2740
|
-
* c2pa-native embed. No signer round trip.
|
|
2751
|
+
* UniFFI polls a future on the thread that called it and never spawns, so an `async fn` whose
|
|
2752
|
+
* body never suspends completes in its first poll, on the caller's thread, blocking it exactly
|
|
2753
|
+
* as a sync export would: measured at 88ms for a 10MB asset on Node, during which nothing else
|
|
2754
|
+
* in the process runs. It is also the read path's hard requirement, not just a courtesy: the
|
|
2755
|
+
* splice reads through `sink`, and the caller's thread is the one that has to answer those
|
|
2756
|
+
* reads. See [`task`](shared::task).
|
|
2741
2757
|
*
|
|
2742
2758
|
* # Errors
|
|
2743
2759
|
*
|
|
@@ -2745,11 +2761,11 @@ async function computeSoftBinding(alg, source, format = void 0, asyncOpts_) {
|
|
|
2745
2761
|
* authoring/`locate` disagrees after the write, or the c2pa handler can't
|
|
2746
2762
|
* parse/splice the asset.
|
|
2747
2763
|
*/
|
|
2748
|
-
async function embed(sink,
|
|
2764
|
+
async function embed(sink, manifest, options, plugins, asyncOpts_) {
|
|
2749
2765
|
const __stack = uniffiIsDebug ? (/* @__PURE__ */ new Error()).stack : void 0;
|
|
2750
2766
|
try {
|
|
2751
2767
|
return await uniffiRustCallAsync(uniffiCaller, () => {
|
|
2752
|
-
return getter().uniffi_trylimbo_sdk_issuer_fn_func_embed(FfiConverterTypeRangeSink.lower(sink, getter().rustbuffer_alloc), FfiConverterArrayBuffer.lower(
|
|
2768
|
+
return getter().uniffi_trylimbo_sdk_issuer_fn_func_embed(FfiConverterTypeRangeSink.lower(sink, getter().rustbuffer_alloc), FfiConverterArrayBuffer.lower(manifest, getter().rustbuffer_alloc), FfiConverterTypeEmbedOptions.lower(options, getter().rustbuffer_alloc), FfiConverterSequenceTypePluginAuthor.lower(plugins, getter().rustbuffer_alloc));
|
|
2753
2769
|
}, getter().ffi_trylimbo_sdk_issuer_rust_future_poll_void, getter().ffi_trylimbo_sdk_issuer_rust_future_cancel_void, getter().ffi_trylimbo_sdk_issuer_rust_future_complete_void, getter().ffi_trylimbo_sdk_issuer_rust_future_free_void, (_v) => {}, FfiConverterString.lift.bind(FfiConverterString), asyncOpts_, FfiConverterTypeSdkError.lift.bind(FfiConverterTypeSdkError));
|
|
2754
2770
|
} catch (__error) {
|
|
2755
2771
|
if (uniffiIsDebug && __error instanceof Error) __error.stack = __stack;
|
|
@@ -2770,34 +2786,7 @@ const FfiConverterString = uniffiCreateFfiConverterString((() => {
|
|
|
2770
2786
|
readStringFromBuffer: (buf, offset, length) => decoder.decode(new Uint8Array(buf.arrayBuffer, offset, length))
|
|
2771
2787
|
};
|
|
2772
2788
|
})());
|
|
2773
|
-
|
|
2774
|
-
* Generated factory for {@link SoftwareAgent} record objects.
|
|
2775
|
-
*/
|
|
2776
|
-
const SoftwareAgent = (() => {
|
|
2777
|
-
const defaults = () => ({});
|
|
2778
|
-
const create = (() => {
|
|
2779
|
-
return uniffiCreateRecord(defaults);
|
|
2780
|
-
})();
|
|
2781
|
-
return Object.freeze({
|
|
2782
|
-
create,
|
|
2783
|
-
new: create,
|
|
2784
|
-
defaults: () => Object.freeze(defaults())
|
|
2785
|
-
});
|
|
2786
|
-
})();
|
|
2787
|
-
const FfiConverterTypeSoftwareAgent = (() => {
|
|
2788
|
-
class FFIConverter extends AbstractFfiConverterByteArray {
|
|
2789
|
-
readFromCursor(c) {
|
|
2790
|
-
return { name: FfiConverterString.readFromCursor(c) };
|
|
2791
|
-
}
|
|
2792
|
-
writeIntoCursor(value, c) {
|
|
2793
|
-
FfiConverterString.writeIntoCursor(value.name, c);
|
|
2794
|
-
}
|
|
2795
|
-
allocationSize(value) {
|
|
2796
|
-
return FfiConverterString.allocationSize(value.name);
|
|
2797
|
-
}
|
|
2798
|
-
}
|
|
2799
|
-
return new FFIConverter();
|
|
2800
|
-
})();
|
|
2789
|
+
const FfiConverterTypeTimestamp = FfiConverterString;
|
|
2801
2790
|
const FfiConverterTypeUrl = FfiConverterString;
|
|
2802
2791
|
/**
|
|
2803
2792
|
* Generated factory for {@link ActionDetail} record objects.
|
|
@@ -2822,20 +2811,20 @@ const FfiConverterTypeActionDetail = (() => {
|
|
|
2822
2811
|
class FFIConverter extends AbstractFfiConverterByteArray {
|
|
2823
2812
|
readFromCursor(c) {
|
|
2824
2813
|
return {
|
|
2825
|
-
when:
|
|
2826
|
-
softwareAgent:
|
|
2814
|
+
when: FfiConverterOptionalTypeTimestamp.readFromCursor(c),
|
|
2815
|
+
softwareAgent: FfiConverterOptionalString.readFromCursor(c),
|
|
2827
2816
|
description: FfiConverterOptionalString.readFromCursor(c),
|
|
2828
2817
|
sourceType: FfiConverterOptionalTypeUrl.readFromCursor(c)
|
|
2829
2818
|
};
|
|
2830
2819
|
}
|
|
2831
2820
|
writeIntoCursor(value, c) {
|
|
2832
|
-
|
|
2833
|
-
|
|
2821
|
+
FfiConverterOptionalTypeTimestamp.writeIntoCursor(value.when, c);
|
|
2822
|
+
FfiConverterOptionalString.writeIntoCursor(value.softwareAgent, c);
|
|
2834
2823
|
FfiConverterOptionalString.writeIntoCursor(value.description, c);
|
|
2835
2824
|
FfiConverterOptionalTypeUrl.writeIntoCursor(value.sourceType, c);
|
|
2836
2825
|
}
|
|
2837
2826
|
allocationSize(value) {
|
|
2838
|
-
return
|
|
2827
|
+
return FfiConverterOptionalTypeTimestamp.allocationSize(value.when) + FfiConverterOptionalString.allocationSize(value.softwareAgent) + FfiConverterOptionalString.allocationSize(value.description) + FfiConverterOptionalTypeUrl.allocationSize(value.sourceType);
|
|
2839
2828
|
}
|
|
2840
2829
|
}
|
|
2841
2830
|
return new FFIConverter();
|
|
@@ -2877,11 +2866,7 @@ const FfiConverterTypeAssertion = (() => {
|
|
|
2877
2866
|
* Generated factory for {@link CreatedOrigin} record objects.
|
|
2878
2867
|
*/
|
|
2879
2868
|
const CreatedOrigin = (() => {
|
|
2880
|
-
const defaults = () => ({
|
|
2881
|
-
when: void 0,
|
|
2882
|
-
softwareAgent: void 0,
|
|
2883
|
-
description: void 0
|
|
2884
|
-
});
|
|
2869
|
+
const defaults = () => ({ detail: void 0 });
|
|
2885
2870
|
const create = (() => {
|
|
2886
2871
|
return uniffiCreateRecord(defaults);
|
|
2887
2872
|
})();
|
|
@@ -2896,25 +2881,25 @@ const FfiConverterTypeCreatedOrigin = (() => {
|
|
|
2896
2881
|
readFromCursor(c) {
|
|
2897
2882
|
return {
|
|
2898
2883
|
sourceType: FfiConverterTypeUrl.readFromCursor(c),
|
|
2899
|
-
|
|
2900
|
-
softwareAgent: FfiConverterOptionalTypeSoftwareAgent.readFromCursor(c),
|
|
2901
|
-
description: FfiConverterOptionalString.readFromCursor(c)
|
|
2884
|
+
detail: FfiConverterOptionalTypeActionDetail.readFromCursor(c)
|
|
2902
2885
|
};
|
|
2903
2886
|
}
|
|
2904
2887
|
writeIntoCursor(value, c) {
|
|
2905
2888
|
FfiConverterTypeUrl.writeIntoCursor(value.sourceType, c);
|
|
2906
|
-
|
|
2907
|
-
FfiConverterOptionalTypeSoftwareAgent.writeIntoCursor(value.softwareAgent, c);
|
|
2908
|
-
FfiConverterOptionalString.writeIntoCursor(value.description, c);
|
|
2889
|
+
FfiConverterOptionalTypeActionDetail.writeIntoCursor(value.detail, c);
|
|
2909
2890
|
}
|
|
2910
2891
|
allocationSize(value) {
|
|
2911
|
-
return FfiConverterTypeUrl.allocationSize(value.sourceType) +
|
|
2892
|
+
return FfiConverterTypeUrl.allocationSize(value.sourceType) + FfiConverterOptionalTypeActionDetail.allocationSize(value.detail);
|
|
2912
2893
|
}
|
|
2913
2894
|
}
|
|
2914
2895
|
return new FFIConverter();
|
|
2915
2896
|
})();
|
|
2916
2897
|
/**
|
|
2917
2898
|
* A canonical gRPC/Connect status code: the coarse, closed failure class.
|
|
2899
|
+
*
|
|
2900
|
+
* The wasm lane projects this as a camelCase string like every other tagged value
|
|
2901
|
+
* there, so a consumer narrows on `err.code === "resourceExhausted"`; the native lane
|
|
2902
|
+
* projects an enum.
|
|
2918
2903
|
*/
|
|
2919
2904
|
let Code = /* @__PURE__ */ function(Code) {
|
|
2920
2905
|
Code[Code["Canceled"] = 0] = "Canceled";
|
|
@@ -3371,68 +3356,160 @@ const uniffiCallbackInterfaceRangeSource = {
|
|
|
3371
3356
|
getter().uniffi_trylimbo_sdk_issuer_fn_init_callback_vtable_rangesource(uniffiCallbackInterfaceRangeSource.vtable);
|
|
3372
3357
|
}
|
|
3373
3358
|
};
|
|
3374
|
-
let
|
|
3375
|
-
|
|
3376
|
-
|
|
3377
|
-
return
|
|
3359
|
+
let AssetFormat_Tags = /* @__PURE__ */ function(AssetFormat_Tags) {
|
|
3360
|
+
AssetFormat_Tags["Sniff"] = "Sniff";
|
|
3361
|
+
AssetFormat_Tags["Declared"] = "Declared";
|
|
3362
|
+
return AssetFormat_Tags;
|
|
3378
3363
|
}({});
|
|
3379
3364
|
/**
|
|
3380
|
-
*
|
|
3365
|
+
* The format of the asset a call is handed. Stated, never defaulted: sniffing is a choice the
|
|
3366
|
+
* caller makes by name, not what happens when they say nothing.
|
|
3381
3367
|
*/
|
|
3382
|
-
const
|
|
3368
|
+
const AssetFormat = (() => {
|
|
3369
|
+
/**
|
|
3370
|
+
* Read the format from the asset's leading bytes.
|
|
3371
|
+
*/
|
|
3372
|
+
class Sniff_ extends UniffiEnum {
|
|
3373
|
+
/**
|
|
3374
|
+
* @private
|
|
3375
|
+
* This field is private and should not be used, use `tag` instead.
|
|
3376
|
+
*/
|
|
3377
|
+
[uniffiTypeNameSymbol] = "AssetFormat";
|
|
3378
|
+
tag = "Sniff";
|
|
3379
|
+
constructor() {
|
|
3380
|
+
super("AssetFormat", "Sniff");
|
|
3381
|
+
}
|
|
3382
|
+
static new() {
|
|
3383
|
+
return new Sniff_();
|
|
3384
|
+
}
|
|
3385
|
+
static instanceOf(obj) {
|
|
3386
|
+
return obj.tag === "Sniff";
|
|
3387
|
+
}
|
|
3388
|
+
}
|
|
3389
|
+
/**
|
|
3390
|
+
* The caller knows the format and states it, as a media type.
|
|
3391
|
+
*/
|
|
3392
|
+
class Declared_ extends UniffiEnum {
|
|
3393
|
+
/**
|
|
3394
|
+
* @private
|
|
3395
|
+
* This field is private and should not be used, use `tag` instead.
|
|
3396
|
+
*/
|
|
3397
|
+
[uniffiTypeNameSymbol] = "AssetFormat";
|
|
3398
|
+
tag = "Declared";
|
|
3399
|
+
inner;
|
|
3400
|
+
constructor(inner) {
|
|
3401
|
+
super("AssetFormat", "Declared");
|
|
3402
|
+
this.inner = Object.freeze(inner);
|
|
3403
|
+
}
|
|
3404
|
+
static new(inner) {
|
|
3405
|
+
return new Declared_(inner);
|
|
3406
|
+
}
|
|
3407
|
+
static instanceOf(obj) {
|
|
3408
|
+
return obj.tag === "Declared";
|
|
3409
|
+
}
|
|
3410
|
+
}
|
|
3411
|
+
function instanceOf(obj) {
|
|
3412
|
+
return obj[uniffiTypeNameSymbol] === "AssetFormat";
|
|
3413
|
+
}
|
|
3414
|
+
return Object.freeze({
|
|
3415
|
+
instanceOf,
|
|
3416
|
+
Sniff: Sniff_,
|
|
3417
|
+
Declared: Declared_
|
|
3418
|
+
});
|
|
3419
|
+
})();
|
|
3420
|
+
const FfiConverterTypeAssetFormat = (() => {
|
|
3421
|
+
class FFIConverter extends AbstractFfiConverterByteArray {
|
|
3422
|
+
readFromCursor(c) {
|
|
3423
|
+
switch (c.readI32()) {
|
|
3424
|
+
case 1: return new AssetFormat.Sniff();
|
|
3425
|
+
case 2: return new AssetFormat.Declared({ mediaType: FfiConverterString.readFromCursor(c) });
|
|
3426
|
+
default: throw new UniffiInternalError.UnexpectedEnumCase();
|
|
3427
|
+
}
|
|
3428
|
+
}
|
|
3429
|
+
writeIntoCursor(value, c) {
|
|
3430
|
+
switch (value.tag) {
|
|
3431
|
+
case "Sniff":
|
|
3432
|
+
c.writeI32(1);
|
|
3433
|
+
return;
|
|
3434
|
+
case "Declared": {
|
|
3435
|
+
c.writeI32(2);
|
|
3436
|
+
const inner = value.inner;
|
|
3437
|
+
FfiConverterString.writeIntoCursor(inner.mediaType, c);
|
|
3438
|
+
return;
|
|
3439
|
+
}
|
|
3440
|
+
default: throw new UniffiInternalError.UnexpectedEnumCase();
|
|
3441
|
+
}
|
|
3442
|
+
}
|
|
3443
|
+
allocationSize(value) {
|
|
3444
|
+
switch (value.tag) {
|
|
3445
|
+
case "Sniff": return 4;
|
|
3446
|
+
case "Declared": {
|
|
3447
|
+
const inner = value.inner;
|
|
3448
|
+
let size = 4;
|
|
3449
|
+
size += FfiConverterString.allocationSize(inner.mediaType);
|
|
3450
|
+
return size;
|
|
3451
|
+
}
|
|
3452
|
+
default: throw new UniffiInternalError.UnexpectedEnumCase();
|
|
3453
|
+
}
|
|
3454
|
+
}
|
|
3455
|
+
}
|
|
3456
|
+
return new FFIConverter();
|
|
3457
|
+
})();
|
|
3458
|
+
let IngredientSource_Tags = /* @__PURE__ */ function(IngredientSource_Tags) {
|
|
3459
|
+
IngredientSource_Tags["Asset"] = "Asset";
|
|
3460
|
+
IngredientSource_Tags["Descriptor"] = "Descriptor";
|
|
3461
|
+
return IngredientSource_Tags;
|
|
3462
|
+
}({});
|
|
3463
|
+
const IngredientSource = (() => {
|
|
3383
3464
|
/**
|
|
3384
3465
|
* The ingredient asset, read in place through `source`; the asset itself never crosses the
|
|
3385
3466
|
* wire, only the manifest it carries and what validating it found.
|
|
3386
|
-
* `format` is the asset's media type; `None` reads it from the leading bytes.
|
|
3387
3467
|
*/
|
|
3388
3468
|
class Asset_ extends UniffiEnum {
|
|
3389
3469
|
/**
|
|
3390
3470
|
* @private
|
|
3391
3471
|
* This field is private and should not be used, use `tag` instead.
|
|
3392
3472
|
*/
|
|
3393
|
-
[uniffiTypeNameSymbol] = "
|
|
3473
|
+
[uniffiTypeNameSymbol] = "IngredientSource";
|
|
3394
3474
|
tag = "Asset";
|
|
3395
3475
|
inner;
|
|
3396
3476
|
constructor(inner) {
|
|
3397
|
-
super("
|
|
3477
|
+
super("IngredientSource", "Asset");
|
|
3398
3478
|
this.inner = Object.freeze(inner);
|
|
3399
3479
|
}
|
|
3400
|
-
static new
|
|
3401
|
-
|
|
3402
|
-
|
|
3403
|
-
discoveredBy: []
|
|
3404
|
-
});
|
|
3405
|
-
const create = uniffiCreateRecord(defaults);
|
|
3406
|
-
return (partial) => new Asset_(create(partial));
|
|
3407
|
-
})();
|
|
3480
|
+
static new(inner) {
|
|
3481
|
+
return new Asset_(inner);
|
|
3482
|
+
}
|
|
3408
3483
|
static instanceOf(obj) {
|
|
3409
3484
|
return obj.tag === "Asset";
|
|
3410
3485
|
}
|
|
3411
3486
|
}
|
|
3412
3487
|
/**
|
|
3413
|
-
* No asset: the ingredient is described by its title and
|
|
3488
|
+
* No asset: the ingredient is described by its title and format alone.
|
|
3414
3489
|
*/
|
|
3415
3490
|
class Descriptor_ extends UniffiEnum {
|
|
3416
3491
|
/**
|
|
3417
3492
|
* @private
|
|
3418
3493
|
* This field is private and should not be used, use `tag` instead.
|
|
3419
3494
|
*/
|
|
3420
|
-
[uniffiTypeNameSymbol] = "
|
|
3495
|
+
[uniffiTypeNameSymbol] = "IngredientSource";
|
|
3421
3496
|
tag = "Descriptor";
|
|
3422
3497
|
inner;
|
|
3423
3498
|
constructor(inner) {
|
|
3424
|
-
super("
|
|
3499
|
+
super("IngredientSource", "Descriptor");
|
|
3425
3500
|
this.inner = Object.freeze(inner);
|
|
3426
3501
|
}
|
|
3427
|
-
static new(
|
|
3428
|
-
|
|
3429
|
-
|
|
3502
|
+
static new = (() => {
|
|
3503
|
+
const defaults = () => ({ format: void 0 });
|
|
3504
|
+
const create = uniffiCreateRecord(defaults);
|
|
3505
|
+
return (partial) => new Descriptor_(create(partial));
|
|
3506
|
+
})();
|
|
3430
3507
|
static instanceOf(obj) {
|
|
3431
3508
|
return obj.tag === "Descriptor";
|
|
3432
3509
|
}
|
|
3433
3510
|
}
|
|
3434
3511
|
function instanceOf(obj) {
|
|
3435
|
-
return obj[uniffiTypeNameSymbol] === "
|
|
3512
|
+
return obj[uniffiTypeNameSymbol] === "IngredientSource";
|
|
3436
3513
|
}
|
|
3437
3514
|
return Object.freeze({
|
|
3438
3515
|
instanceOf,
|
|
@@ -3440,16 +3517,15 @@ const IngredientKind = (() => {
|
|
|
3440
3517
|
Descriptor: Descriptor_
|
|
3441
3518
|
});
|
|
3442
3519
|
})();
|
|
3443
|
-
const
|
|
3520
|
+
const FfiConverterTypeIngredientSource = (() => {
|
|
3444
3521
|
class FFIConverter extends AbstractFfiConverterByteArray {
|
|
3445
3522
|
readFromCursor(c) {
|
|
3446
3523
|
switch (c.readI32()) {
|
|
3447
|
-
case 1: return new
|
|
3524
|
+
case 1: return new IngredientSource.Asset({
|
|
3448
3525
|
source: FfiConverterTypeRangeSource.readFromCursor(c),
|
|
3449
|
-
format:
|
|
3450
|
-
discoveredBy: FfiConverterSequenceString.readFromCursor(c)
|
|
3526
|
+
format: FfiConverterTypeAssetFormat.readFromCursor(c)
|
|
3451
3527
|
});
|
|
3452
|
-
case 2: return new
|
|
3528
|
+
case 2: return new IngredientSource.Descriptor({ format: FfiConverterOptionalString.readFromCursor(c) });
|
|
3453
3529
|
default: throw new UniffiInternalError.UnexpectedEnumCase();
|
|
3454
3530
|
}
|
|
3455
3531
|
}
|
|
@@ -3459,14 +3535,13 @@ const FfiConverterTypeIngredientKind = (() => {
|
|
|
3459
3535
|
c.writeI32(1);
|
|
3460
3536
|
const inner = value.inner;
|
|
3461
3537
|
FfiConverterTypeRangeSource.writeIntoCursor(inner.source, c);
|
|
3462
|
-
|
|
3463
|
-
FfiConverterSequenceString.writeIntoCursor(inner.discoveredBy, c);
|
|
3538
|
+
FfiConverterTypeAssetFormat.writeIntoCursor(inner.format, c);
|
|
3464
3539
|
return;
|
|
3465
3540
|
}
|
|
3466
3541
|
case "Descriptor": {
|
|
3467
3542
|
c.writeI32(2);
|
|
3468
3543
|
const inner = value.inner;
|
|
3469
|
-
|
|
3544
|
+
FfiConverterOptionalString.writeIntoCursor(inner.format, c);
|
|
3470
3545
|
return;
|
|
3471
3546
|
}
|
|
3472
3547
|
default: throw new UniffiInternalError.UnexpectedEnumCase();
|
|
@@ -3478,14 +3553,13 @@ const FfiConverterTypeIngredientKind = (() => {
|
|
|
3478
3553
|
const inner = value.inner;
|
|
3479
3554
|
let size = 4;
|
|
3480
3555
|
size += FfiConverterTypeRangeSource.allocationSize(inner.source);
|
|
3481
|
-
size +=
|
|
3482
|
-
size += FfiConverterSequenceString.allocationSize(inner.discoveredBy);
|
|
3556
|
+
size += FfiConverterTypeAssetFormat.allocationSize(inner.format);
|
|
3483
3557
|
return size;
|
|
3484
3558
|
}
|
|
3485
3559
|
case "Descriptor": {
|
|
3486
3560
|
const inner = value.inner;
|
|
3487
3561
|
let size = 4;
|
|
3488
|
-
size +=
|
|
3562
|
+
size += FfiConverterOptionalString.allocationSize(inner.format);
|
|
3489
3563
|
return size;
|
|
3490
3564
|
}
|
|
3491
3565
|
default: throw new UniffiInternalError.UnexpectedEnumCase();
|
|
@@ -3498,7 +3572,7 @@ const FfiConverterTypeIngredientKind = (() => {
|
|
|
3498
3572
|
* Generated factory for {@link Thumbnail} record objects.
|
|
3499
3573
|
*/
|
|
3500
3574
|
const Thumbnail = (() => {
|
|
3501
|
-
const defaults = () => ({
|
|
3575
|
+
const defaults = () => ({});
|
|
3502
3576
|
const create = (() => {
|
|
3503
3577
|
return uniffiCreateRecord(defaults);
|
|
3504
3578
|
})();
|
|
@@ -3513,15 +3587,15 @@ const FfiConverterTypeThumbnail = (() => {
|
|
|
3513
3587
|
readFromCursor(c) {
|
|
3514
3588
|
return {
|
|
3515
3589
|
data: FfiConverterArrayBuffer.readFromCursor(c),
|
|
3516
|
-
format:
|
|
3590
|
+
format: FfiConverterString.readFromCursor(c)
|
|
3517
3591
|
};
|
|
3518
3592
|
}
|
|
3519
3593
|
writeIntoCursor(value, c) {
|
|
3520
3594
|
FfiConverterArrayBuffer.writeIntoCursor(value.data, c);
|
|
3521
|
-
|
|
3595
|
+
FfiConverterString.writeIntoCursor(value.format, c);
|
|
3522
3596
|
}
|
|
3523
3597
|
allocationSize(value) {
|
|
3524
|
-
return FfiConverterArrayBuffer.allocationSize(value.data) +
|
|
3598
|
+
return FfiConverterArrayBuffer.allocationSize(value.data) + FfiConverterString.allocationSize(value.format);
|
|
3525
3599
|
}
|
|
3526
3600
|
}
|
|
3527
3601
|
return new FFIConverter();
|
|
@@ -3547,18 +3621,20 @@ const FfiConverterTypeIngredient = (() => {
|
|
|
3547
3621
|
class FFIConverter extends AbstractFfiConverterByteArray {
|
|
3548
3622
|
readFromCursor(c) {
|
|
3549
3623
|
return {
|
|
3550
|
-
|
|
3624
|
+
source: FfiConverterTypeIngredientSource.readFromCursor(c),
|
|
3551
3625
|
title: FfiConverterOptionalString.readFromCursor(c),
|
|
3552
|
-
thumbnail: FfiConverterOptionalTypeThumbnail.readFromCursor(c)
|
|
3626
|
+
thumbnail: FfiConverterOptionalTypeThumbnail.readFromCursor(c),
|
|
3627
|
+
discoveredBy: FfiConverterSequenceString.readFromCursor(c)
|
|
3553
3628
|
};
|
|
3554
3629
|
}
|
|
3555
3630
|
writeIntoCursor(value, c) {
|
|
3556
|
-
|
|
3631
|
+
FfiConverterTypeIngredientSource.writeIntoCursor(value.source, c);
|
|
3557
3632
|
FfiConverterOptionalString.writeIntoCursor(value.title, c);
|
|
3558
3633
|
FfiConverterOptionalTypeThumbnail.writeIntoCursor(value.thumbnail, c);
|
|
3634
|
+
FfiConverterSequenceString.writeIntoCursor(value.discoveredBy, c);
|
|
3559
3635
|
}
|
|
3560
3636
|
allocationSize(value) {
|
|
3561
|
-
return
|
|
3637
|
+
return FfiConverterTypeIngredientSource.allocationSize(value.source) + FfiConverterOptionalString.allocationSize(value.title) + FfiConverterOptionalTypeThumbnail.allocationSize(value.thumbnail) + FfiConverterSequenceString.allocationSize(value.discoveredBy);
|
|
3562
3638
|
}
|
|
3563
3639
|
}
|
|
3564
3640
|
return new FFIConverter();
|
|
@@ -3738,10 +3814,7 @@ const FfiConverterTypeJsonObject = FfiConverterString;
|
|
|
3738
3814
|
* Generated factory for {@link CustomAction} record objects.
|
|
3739
3815
|
*/
|
|
3740
3816
|
const CustomAction = (() => {
|
|
3741
|
-
const defaults = () => ({
|
|
3742
|
-
detail: void 0,
|
|
3743
|
-
componentIds: []
|
|
3744
|
-
});
|
|
3817
|
+
const defaults = () => ({ detail: void 0 });
|
|
3745
3818
|
const create = (() => {
|
|
3746
3819
|
return uniffiCreateRecord(defaults);
|
|
3747
3820
|
})();
|
|
@@ -3756,27 +3829,27 @@ const FfiConverterTypeCustomAction = (() => {
|
|
|
3756
3829
|
readFromCursor(c) {
|
|
3757
3830
|
return {
|
|
3758
3831
|
label: FfiConverterString.readFromCursor(c),
|
|
3759
|
-
|
|
3832
|
+
params: FfiConverterTypeJsonObject.readFromCursor(c),
|
|
3760
3833
|
detail: FfiConverterOptionalTypeActionDetail.readFromCursor(c),
|
|
3761
3834
|
componentIds: FfiConverterSequenceString.readFromCursor(c)
|
|
3762
3835
|
};
|
|
3763
3836
|
}
|
|
3764
3837
|
writeIntoCursor(value, c) {
|
|
3765
3838
|
FfiConverterString.writeIntoCursor(value.label, c);
|
|
3766
|
-
FfiConverterTypeJsonObject.writeIntoCursor(value.
|
|
3839
|
+
FfiConverterTypeJsonObject.writeIntoCursor(value.params, c);
|
|
3767
3840
|
FfiConverterOptionalTypeActionDetail.writeIntoCursor(value.detail, c);
|
|
3768
3841
|
FfiConverterSequenceString.writeIntoCursor(value.componentIds, c);
|
|
3769
3842
|
}
|
|
3770
3843
|
allocationSize(value) {
|
|
3771
|
-
return FfiConverterString.allocationSize(value.label) + FfiConverterTypeJsonObject.allocationSize(value.
|
|
3844
|
+
return FfiConverterString.allocationSize(value.label) + FfiConverterTypeJsonObject.allocationSize(value.params) + FfiConverterOptionalTypeActionDetail.allocationSize(value.detail) + FfiConverterSequenceString.allocationSize(value.componentIds);
|
|
3772
3845
|
}
|
|
3773
3846
|
}
|
|
3774
3847
|
return new FFIConverter();
|
|
3775
3848
|
})();
|
|
3776
3849
|
/**
|
|
3777
|
-
* Generated factory for {@link
|
|
3850
|
+
* Generated factory for {@link SoftBinding} record objects.
|
|
3778
3851
|
*/
|
|
3779
|
-
const
|
|
3852
|
+
const SoftBinding = (() => {
|
|
3780
3853
|
const defaults = () => ({});
|
|
3781
3854
|
const create = (() => {
|
|
3782
3855
|
return uniffiCreateRecord(defaults);
|
|
@@ -3787,112 +3860,20 @@ const Timespan = (() => {
|
|
|
3787
3860
|
defaults: () => Object.freeze(defaults())
|
|
3788
3861
|
});
|
|
3789
3862
|
})();
|
|
3790
|
-
const
|
|
3863
|
+
const FfiConverterTypeSoftBinding = (() => {
|
|
3791
3864
|
class FFIConverter extends AbstractFfiConverterByteArray {
|
|
3792
3865
|
readFromCursor(c) {
|
|
3793
3866
|
return {
|
|
3794
|
-
|
|
3795
|
-
|
|
3867
|
+
alg: FfiConverterString.readFromCursor(c),
|
|
3868
|
+
value: FfiConverterString.readFromCursor(c)
|
|
3796
3869
|
};
|
|
3797
3870
|
}
|
|
3798
3871
|
writeIntoCursor(value, c) {
|
|
3799
|
-
|
|
3800
|
-
|
|
3872
|
+
FfiConverterString.writeIntoCursor(value.alg, c);
|
|
3873
|
+
FfiConverterString.writeIntoCursor(value.value, c);
|
|
3801
3874
|
}
|
|
3802
3875
|
allocationSize(value) {
|
|
3803
|
-
return
|
|
3804
|
-
}
|
|
3805
|
-
}
|
|
3806
|
-
return new FFIConverter();
|
|
3807
|
-
})();
|
|
3808
|
-
/**
|
|
3809
|
-
* Generated factory for {@link Scope} record objects.
|
|
3810
|
-
*/
|
|
3811
|
-
const Scope = (() => {
|
|
3812
|
-
const defaults = () => ({ timespan: void 0 });
|
|
3813
|
-
const create = (() => {
|
|
3814
|
-
return uniffiCreateRecord(defaults);
|
|
3815
|
-
})();
|
|
3816
|
-
return Object.freeze({
|
|
3817
|
-
create,
|
|
3818
|
-
new: create,
|
|
3819
|
-
defaults: () => Object.freeze(defaults())
|
|
3820
|
-
});
|
|
3821
|
-
})();
|
|
3822
|
-
const FfiConverterTypeScope = (() => {
|
|
3823
|
-
class FFIConverter extends AbstractFfiConverterByteArray {
|
|
3824
|
-
readFromCursor(c) {
|
|
3825
|
-
return { timespan: FfiConverterOptionalTypeTimespan.readFromCursor(c) };
|
|
3826
|
-
}
|
|
3827
|
-
writeIntoCursor(value, c) {
|
|
3828
|
-
FfiConverterOptionalTypeTimespan.writeIntoCursor(value.timespan, c);
|
|
3829
|
-
}
|
|
3830
|
-
allocationSize(value) {
|
|
3831
|
-
return FfiConverterOptionalTypeTimespan.allocationSize(value.timespan);
|
|
3832
|
-
}
|
|
3833
|
-
}
|
|
3834
|
-
return new FFIConverter();
|
|
3835
|
-
})();
|
|
3836
|
-
/**
|
|
3837
|
-
* Generated factory for {@link Block} record objects.
|
|
3838
|
-
*/
|
|
3839
|
-
const Block = (() => {
|
|
3840
|
-
const defaults = () => ({ scope: Scope.create({}) });
|
|
3841
|
-
const create = (() => {
|
|
3842
|
-
return uniffiCreateRecord(defaults);
|
|
3843
|
-
})();
|
|
3844
|
-
return Object.freeze({
|
|
3845
|
-
create,
|
|
3846
|
-
new: create,
|
|
3847
|
-
defaults: () => Object.freeze(defaults())
|
|
3848
|
-
});
|
|
3849
|
-
})();
|
|
3850
|
-
const FfiConverterTypeBlock = (() => {
|
|
3851
|
-
class FFIConverter extends AbstractFfiConverterByteArray {
|
|
3852
|
-
readFromCursor(c) {
|
|
3853
|
-
return {
|
|
3854
|
-
value: FfiConverterArrayBuffer.readFromCursor(c),
|
|
3855
|
-
scope: FfiConverterTypeScope.readFromCursor(c)
|
|
3856
|
-
};
|
|
3857
|
-
}
|
|
3858
|
-
writeIntoCursor(value, c) {
|
|
3859
|
-
FfiConverterArrayBuffer.writeIntoCursor(value.value, c);
|
|
3860
|
-
FfiConverterTypeScope.writeIntoCursor(value.scope, c);
|
|
3861
|
-
}
|
|
3862
|
-
allocationSize(value) {
|
|
3863
|
-
return FfiConverterArrayBuffer.allocationSize(value.value) + FfiConverterTypeScope.allocationSize(value.scope);
|
|
3864
|
-
}
|
|
3865
|
-
}
|
|
3866
|
-
return new FFIConverter();
|
|
3867
|
-
})();
|
|
3868
|
-
/**
|
|
3869
|
-
* Generated factory for {@link SoftBinding} record objects.
|
|
3870
|
-
*/
|
|
3871
|
-
const SoftBinding = (() => {
|
|
3872
|
-
const defaults = () => ({});
|
|
3873
|
-
const create = (() => {
|
|
3874
|
-
return uniffiCreateRecord(defaults);
|
|
3875
|
-
})();
|
|
3876
|
-
return Object.freeze({
|
|
3877
|
-
create,
|
|
3878
|
-
new: create,
|
|
3879
|
-
defaults: () => Object.freeze(defaults())
|
|
3880
|
-
});
|
|
3881
|
-
})();
|
|
3882
|
-
const FfiConverterTypeSoftBinding = (() => {
|
|
3883
|
-
class FFIConverter extends AbstractFfiConverterByteArray {
|
|
3884
|
-
readFromCursor(c) {
|
|
3885
|
-
return {
|
|
3886
|
-
alg: FfiConverterString.readFromCursor(c),
|
|
3887
|
-
blocks: FfiConverterSequenceTypeBlock.readFromCursor(c)
|
|
3888
|
-
};
|
|
3889
|
-
}
|
|
3890
|
-
writeIntoCursor(value, c) {
|
|
3891
|
-
FfiConverterString.writeIntoCursor(value.alg, c);
|
|
3892
|
-
FfiConverterSequenceTypeBlock.writeIntoCursor(value.blocks, c);
|
|
3893
|
-
}
|
|
3894
|
-
allocationSize(value) {
|
|
3895
|
-
return FfiConverterString.allocationSize(value.alg) + FfiConverterSequenceTypeBlock.allocationSize(value.blocks);
|
|
3876
|
+
return FfiConverterString.allocationSize(value.alg) + FfiConverterString.allocationSize(value.value);
|
|
3896
3877
|
}
|
|
3897
3878
|
}
|
|
3898
3879
|
return new FFIConverter();
|
|
@@ -3920,13 +3901,14 @@ let ActionKind_Tags = /* @__PURE__ */ function(ActionKind_Tags) {
|
|
|
3920
3901
|
ActionKind_Tags["ResizedProportional"] = "ResizedProportional";
|
|
3921
3902
|
ActionKind_Tags["Transcoded"] = "Transcoded";
|
|
3922
3903
|
ActionKind_Tags["Trimmed"] = "Trimmed";
|
|
3904
|
+
ActionKind_Tags["Unknown"] = "Unknown";
|
|
3923
3905
|
ActionKind_Tags["WatermarkedBound"] = "WatermarkedBound";
|
|
3924
3906
|
ActionKind_Tags["WatermarkedUnbound"] = "WatermarkedUnbound";
|
|
3925
3907
|
return ActionKind_Tags;
|
|
3926
3908
|
}({});
|
|
3927
3909
|
/**
|
|
3928
|
-
* The C2PA 2.
|
|
3929
|
-
* Mirrored for the one variant that carries a binding, which crosses as the
|
|
3910
|
+
* The C2PA 2.3 workflow actions; see the core [`provenance::ActionKind`] for what each is.
|
|
3911
|
+
* Mirrored for the one variant that carries a binding, which crosses as the two-string record.
|
|
3930
3912
|
*/
|
|
3931
3913
|
const ActionKind = (() => {
|
|
3932
3914
|
class AddedText_ extends UniffiEnum {
|
|
@@ -4303,6 +4285,23 @@ const ActionKind = (() => {
|
|
|
4303
4285
|
return obj.tag === "Trimmed";
|
|
4304
4286
|
}
|
|
4305
4287
|
}
|
|
4288
|
+
class Unknown_ extends UniffiEnum {
|
|
4289
|
+
/**
|
|
4290
|
+
* @private
|
|
4291
|
+
* This field is private and should not be used, use `tag` instead.
|
|
4292
|
+
*/
|
|
4293
|
+
[uniffiTypeNameSymbol] = "ActionKind";
|
|
4294
|
+
tag = "Unknown";
|
|
4295
|
+
constructor() {
|
|
4296
|
+
super("ActionKind", "Unknown");
|
|
4297
|
+
}
|
|
4298
|
+
static new() {
|
|
4299
|
+
return new Unknown_();
|
|
4300
|
+
}
|
|
4301
|
+
static instanceOf(obj) {
|
|
4302
|
+
return obj.tag === "Unknown";
|
|
4303
|
+
}
|
|
4304
|
+
}
|
|
4306
4305
|
class WatermarkedBound_ extends UniffiEnum {
|
|
4307
4306
|
/**
|
|
4308
4307
|
* @private
|
|
@@ -4366,6 +4365,7 @@ const ActionKind = (() => {
|
|
|
4366
4365
|
ResizedProportional: ResizedProportional_,
|
|
4367
4366
|
Transcoded: Transcoded_,
|
|
4368
4367
|
Trimmed: Trimmed_,
|
|
4368
|
+
Unknown: Unknown_,
|
|
4369
4369
|
WatermarkedBound: WatermarkedBound_,
|
|
4370
4370
|
WatermarkedUnbound: WatermarkedUnbound_
|
|
4371
4371
|
});
|
|
@@ -4396,8 +4396,9 @@ const FfiConverterTypeActionKind = (() => {
|
|
|
4396
4396
|
case 20: return new ActionKind.ResizedProportional();
|
|
4397
4397
|
case 21: return new ActionKind.Transcoded();
|
|
4398
4398
|
case 22: return new ActionKind.Trimmed();
|
|
4399
|
-
case 23: return new ActionKind.
|
|
4400
|
-
case 24: return new ActionKind.
|
|
4399
|
+
case 23: return new ActionKind.Unknown();
|
|
4400
|
+
case 24: return new ActionKind.WatermarkedBound({ binding: FfiConverterTypeSoftBinding.readFromCursor(c) });
|
|
4401
|
+
case 25: return new ActionKind.WatermarkedUnbound();
|
|
4401
4402
|
default: throw new UniffiInternalError.UnexpectedEnumCase();
|
|
4402
4403
|
}
|
|
4403
4404
|
}
|
|
@@ -4469,14 +4470,17 @@ const FfiConverterTypeActionKind = (() => {
|
|
|
4469
4470
|
case "Trimmed":
|
|
4470
4471
|
c.writeI32(22);
|
|
4471
4472
|
return;
|
|
4472
|
-
case "
|
|
4473
|
+
case "Unknown":
|
|
4473
4474
|
c.writeI32(23);
|
|
4475
|
+
return;
|
|
4476
|
+
case "WatermarkedBound": {
|
|
4477
|
+
c.writeI32(24);
|
|
4474
4478
|
const inner = value.inner;
|
|
4475
4479
|
FfiConverterTypeSoftBinding.writeIntoCursor(inner.binding, c);
|
|
4476
4480
|
return;
|
|
4477
4481
|
}
|
|
4478
4482
|
case "WatermarkedUnbound":
|
|
4479
|
-
c.writeI32(
|
|
4483
|
+
c.writeI32(25);
|
|
4480
4484
|
return;
|
|
4481
4485
|
default: throw new UniffiInternalError.UnexpectedEnumCase();
|
|
4482
4486
|
}
|
|
@@ -4505,6 +4509,7 @@ const FfiConverterTypeActionKind = (() => {
|
|
|
4505
4509
|
case "ResizedProportional": return 4;
|
|
4506
4510
|
case "Transcoded": return 4;
|
|
4507
4511
|
case "Trimmed": return 4;
|
|
4512
|
+
case "Unknown": return 4;
|
|
4508
4513
|
case "WatermarkedBound": {
|
|
4509
4514
|
const inner = value.inner;
|
|
4510
4515
|
let size = 4;
|
|
@@ -4522,10 +4527,7 @@ const FfiConverterTypeActionKind = (() => {
|
|
|
4522
4527
|
* Generated factory for {@link StandardAction} record objects.
|
|
4523
4528
|
*/
|
|
4524
4529
|
const StandardAction = (() => {
|
|
4525
|
-
const defaults = () => ({
|
|
4526
|
-
detail: void 0,
|
|
4527
|
-
componentIds: []
|
|
4528
|
-
});
|
|
4530
|
+
const defaults = () => ({ detail: void 0 });
|
|
4529
4531
|
const create = (() => {
|
|
4530
4532
|
return uniffiCreateRecord(defaults);
|
|
4531
4533
|
})();
|
|
@@ -4658,7 +4660,7 @@ const FfiConverterTypeAction = (() => {
|
|
|
4658
4660
|
* Generated factory for {@link Identity} record objects.
|
|
4659
4661
|
*/
|
|
4660
4662
|
const Identity = (() => {
|
|
4661
|
-
const defaults = () => ({
|
|
4663
|
+
const defaults = () => ({});
|
|
4662
4664
|
const create = (() => {
|
|
4663
4665
|
return uniffiCreateRecord(defaults);
|
|
4664
4666
|
})();
|
|
@@ -4721,9 +4723,6 @@ const ComponentEvent = (() => {
|
|
|
4721
4723
|
return obj.tag === "Placed";
|
|
4722
4724
|
}
|
|
4723
4725
|
}
|
|
4724
|
-
/**
|
|
4725
|
-
* `label` names the ingredient assertion the parent's active manifest holds for it.
|
|
4726
|
-
*/
|
|
4727
4726
|
class Removed_ extends UniffiEnum {
|
|
4728
4727
|
/**
|
|
4729
4728
|
* @private
|
|
@@ -4777,10 +4776,7 @@ const FfiConverterTypeComponentEvent = (() => {
|
|
|
4777
4776
|
readFromCursor(c) {
|
|
4778
4777
|
switch (c.readI32()) {
|
|
4779
4778
|
case 1: return new ComponentEvent.Placed({ detail: FfiConverterOptionalTypeActionDetail.readFromCursor(c) });
|
|
4780
|
-
case 2: return new ComponentEvent.Removed({
|
|
4781
|
-
label: FfiConverterString.readFromCursor(c),
|
|
4782
|
-
detail: FfiConverterOptionalTypeActionDetail.readFromCursor(c)
|
|
4783
|
-
});
|
|
4779
|
+
case 2: return new ComponentEvent.Removed({ detail: FfiConverterOptionalTypeActionDetail.readFromCursor(c) });
|
|
4784
4780
|
case 3: return new ComponentEvent.InputTo();
|
|
4785
4781
|
default: throw new UniffiInternalError.UnexpectedEnumCase();
|
|
4786
4782
|
}
|
|
@@ -4796,7 +4792,6 @@ const FfiConverterTypeComponentEvent = (() => {
|
|
|
4796
4792
|
case "Removed": {
|
|
4797
4793
|
c.writeI32(2);
|
|
4798
4794
|
const inner = value.inner;
|
|
4799
|
-
FfiConverterString.writeIntoCursor(inner.label, c);
|
|
4800
4795
|
FfiConverterOptionalTypeActionDetail.writeIntoCursor(inner.detail, c);
|
|
4801
4796
|
return;
|
|
4802
4797
|
}
|
|
@@ -4817,7 +4812,6 @@ const FfiConverterTypeComponentEvent = (() => {
|
|
|
4817
4812
|
case "Removed": {
|
|
4818
4813
|
const inner = value.inner;
|
|
4819
4814
|
let size = 4;
|
|
4820
|
-
size += FfiConverterString.allocationSize(inner.label);
|
|
4821
4815
|
size += FfiConverterOptionalTypeActionDetail.allocationSize(inner.detail);
|
|
4822
4816
|
return size;
|
|
4823
4817
|
}
|
|
@@ -4846,16 +4840,18 @@ const FfiConverterTypeComponent = (() => {
|
|
|
4846
4840
|
class FFIConverter extends AbstractFfiConverterByteArray {
|
|
4847
4841
|
readFromCursor(c) {
|
|
4848
4842
|
return {
|
|
4843
|
+
id: FfiConverterString.readFromCursor(c),
|
|
4849
4844
|
asset: FfiConverterTypeIngredient.readFromCursor(c),
|
|
4850
4845
|
event: FfiConverterTypeComponentEvent.readFromCursor(c)
|
|
4851
4846
|
};
|
|
4852
4847
|
}
|
|
4853
4848
|
writeIntoCursor(value, c) {
|
|
4849
|
+
FfiConverterString.writeIntoCursor(value.id, c);
|
|
4854
4850
|
FfiConverterTypeIngredient.writeIntoCursor(value.asset, c);
|
|
4855
4851
|
FfiConverterTypeComponentEvent.writeIntoCursor(value.event, c);
|
|
4856
4852
|
}
|
|
4857
4853
|
allocationSize(value) {
|
|
4858
|
-
return FfiConverterTypeIngredient.allocationSize(value.asset) + FfiConverterTypeComponentEvent.allocationSize(value.event);
|
|
4854
|
+
return FfiConverterString.allocationSize(value.id) + FfiConverterTypeIngredient.allocationSize(value.asset) + FfiConverterTypeComponentEvent.allocationSize(value.event);
|
|
4859
4855
|
}
|
|
4860
4856
|
}
|
|
4861
4857
|
return new FFIConverter();
|
|
@@ -4866,10 +4862,7 @@ const FfiConverterTypeComponent = (() => {
|
|
|
4866
4862
|
const AssetManifestSpec = (() => {
|
|
4867
4863
|
const defaults = () => ({
|
|
4868
4864
|
title: void 0,
|
|
4869
|
-
|
|
4870
|
-
identity: void 0,
|
|
4871
|
-
assertions: [],
|
|
4872
|
-
components: /* @__PURE__ */ new Map()
|
|
4865
|
+
identity: void 0
|
|
4873
4866
|
});
|
|
4874
4867
|
const create = (() => {
|
|
4875
4868
|
return uniffiCreateRecord(defaults);
|
|
@@ -4889,7 +4882,7 @@ const FfiConverterTypeAssetManifestSpec = (() => {
|
|
|
4889
4882
|
actions: FfiConverterSequenceTypeAction.readFromCursor(c),
|
|
4890
4883
|
identity: FfiConverterOptionalTypeIdentity.readFromCursor(c),
|
|
4891
4884
|
assertions: FfiConverterSequenceTypeAssertion.readFromCursor(c),
|
|
4892
|
-
components:
|
|
4885
|
+
components: FfiConverterSequenceTypeComponent.readFromCursor(c)
|
|
4893
4886
|
};
|
|
4894
4887
|
}
|
|
4895
4888
|
writeIntoCursor(value, c) {
|
|
@@ -4898,74 +4891,10 @@ const FfiConverterTypeAssetManifestSpec = (() => {
|
|
|
4898
4891
|
FfiConverterSequenceTypeAction.writeIntoCursor(value.actions, c);
|
|
4899
4892
|
FfiConverterOptionalTypeIdentity.writeIntoCursor(value.identity, c);
|
|
4900
4893
|
FfiConverterSequenceTypeAssertion.writeIntoCursor(value.assertions, c);
|
|
4901
|
-
|
|
4894
|
+
FfiConverterSequenceTypeComponent.writeIntoCursor(value.components, c);
|
|
4902
4895
|
}
|
|
4903
4896
|
allocationSize(value) {
|
|
4904
|
-
return FfiConverterOptionalString.allocationSize(value.title) + FfiConverterTypeAssetOrigin.allocationSize(value.origin) + FfiConverterSequenceTypeAction.allocationSize(value.actions) + FfiConverterOptionalTypeIdentity.allocationSize(value.identity) + FfiConverterSequenceTypeAssertion.allocationSize(value.assertions) +
|
|
4905
|
-
}
|
|
4906
|
-
}
|
|
4907
|
-
return new FFIConverter();
|
|
4908
|
-
})();
|
|
4909
|
-
/**
|
|
4910
|
-
* Generated factory for {@link ByteRange} record objects.
|
|
4911
|
-
*/
|
|
4912
|
-
const ByteRange = (() => {
|
|
4913
|
-
const defaults = () => ({});
|
|
4914
|
-
const create = (() => {
|
|
4915
|
-
return uniffiCreateRecord(defaults);
|
|
4916
|
-
})();
|
|
4917
|
-
return Object.freeze({
|
|
4918
|
-
create,
|
|
4919
|
-
new: create,
|
|
4920
|
-
defaults: () => Object.freeze(defaults())
|
|
4921
|
-
});
|
|
4922
|
-
})();
|
|
4923
|
-
const FfiConverterTypeByteRange = (() => {
|
|
4924
|
-
class FFIConverter extends AbstractFfiConverterByteArray {
|
|
4925
|
-
readFromCursor(c) {
|
|
4926
|
-
return {
|
|
4927
|
-
offset: FfiConverterUInt64.readFromCursor(c),
|
|
4928
|
-
length: FfiConverterUInt64.readFromCursor(c)
|
|
4929
|
-
};
|
|
4930
|
-
}
|
|
4931
|
-
writeIntoCursor(value, c) {
|
|
4932
|
-
FfiConverterUInt64.writeIntoCursor(value.offset, c);
|
|
4933
|
-
FfiConverterUInt64.writeIntoCursor(value.length, c);
|
|
4934
|
-
}
|
|
4935
|
-
allocationSize(value) {
|
|
4936
|
-
return FfiConverterUInt64.allocationSize(value.offset) + FfiConverterUInt64.allocationSize(value.length);
|
|
4937
|
-
}
|
|
4938
|
-
}
|
|
4939
|
-
return new FFIConverter();
|
|
4940
|
-
})();
|
|
4941
|
-
/**
|
|
4942
|
-
* Generated factory for {@link ComputeRequest} record objects.
|
|
4943
|
-
*/
|
|
4944
|
-
const ComputeRequest = (() => {
|
|
4945
|
-
const defaults = () => ({});
|
|
4946
|
-
const create = (() => {
|
|
4947
|
-
return uniffiCreateRecord(defaults);
|
|
4948
|
-
})();
|
|
4949
|
-
return Object.freeze({
|
|
4950
|
-
create,
|
|
4951
|
-
new: create,
|
|
4952
|
-
defaults: () => Object.freeze(defaults())
|
|
4953
|
-
});
|
|
4954
|
-
})();
|
|
4955
|
-
const FfiConverterTypeComputeRequest = (() => {
|
|
4956
|
-
class FFIConverter extends AbstractFfiConverterByteArray {
|
|
4957
|
-
readFromCursor(c) {
|
|
4958
|
-
return {
|
|
4959
|
-
source: FfiConverterTypeRangeSource.readFromCursor(c),
|
|
4960
|
-
format: FfiConverterString.readFromCursor(c)
|
|
4961
|
-
};
|
|
4962
|
-
}
|
|
4963
|
-
writeIntoCursor(value, c) {
|
|
4964
|
-
FfiConverterTypeRangeSource.writeIntoCursor(value.source, c);
|
|
4965
|
-
FfiConverterString.writeIntoCursor(value.format, c);
|
|
4966
|
-
}
|
|
4967
|
-
allocationSize(value) {
|
|
4968
|
-
return FfiConverterTypeRangeSource.allocationSize(value.source) + FfiConverterString.allocationSize(value.format);
|
|
4897
|
+
return FfiConverterOptionalString.allocationSize(value.title) + FfiConverterTypeAssetOrigin.allocationSize(value.origin) + FfiConverterSequenceTypeAction.allocationSize(value.actions) + FfiConverterOptionalTypeIdentity.allocationSize(value.identity) + FfiConverterSequenceTypeAssertion.allocationSize(value.assertions) + FfiConverterSequenceTypeComponent.allocationSize(value.components);
|
|
4969
4898
|
}
|
|
4970
4899
|
}
|
|
4971
4900
|
return new FFIConverter();
|
|
@@ -4974,11 +4903,7 @@ const FfiConverterTypeComputeRequest = (() => {
|
|
|
4974
4903
|
* Generated factory for {@link ConnectOptions} record objects.
|
|
4975
4904
|
*/
|
|
4976
4905
|
const ConnectOptions = (() => {
|
|
4977
|
-
const defaults = () => ({
|
|
4978
|
-
headers: /* @__PURE__ */ new Map(),
|
|
4979
|
-
rpcTimeout: void 0,
|
|
4980
|
-
connectTimeout: void 0
|
|
4981
|
-
});
|
|
4906
|
+
const defaults = () => ({ headers: void 0 });
|
|
4982
4907
|
const create = (() => {
|
|
4983
4908
|
return uniffiCreateRecord(defaults);
|
|
4984
4909
|
})();
|
|
@@ -4992,27 +4917,27 @@ const FfiConverterTypeConnectOptions = (() => {
|
|
|
4992
4917
|
class FFIConverter extends AbstractFfiConverterByteArray {
|
|
4993
4918
|
readFromCursor(c) {
|
|
4994
4919
|
return {
|
|
4995
|
-
headers:
|
|
4996
|
-
|
|
4997
|
-
|
|
4920
|
+
headers: FfiConverterOptionalMapStringString.readFromCursor(c),
|
|
4921
|
+
rpcTimeoutMs: FfiConverterUInt32.readFromCursor(c),
|
|
4922
|
+
connectTimeoutMs: FfiConverterUInt32.readFromCursor(c)
|
|
4998
4923
|
};
|
|
4999
4924
|
}
|
|
5000
4925
|
writeIntoCursor(value, c) {
|
|
5001
|
-
|
|
5002
|
-
|
|
5003
|
-
|
|
4926
|
+
FfiConverterOptionalMapStringString.writeIntoCursor(value.headers, c);
|
|
4927
|
+
FfiConverterUInt32.writeIntoCursor(value.rpcTimeoutMs, c);
|
|
4928
|
+
FfiConverterUInt32.writeIntoCursor(value.connectTimeoutMs, c);
|
|
5004
4929
|
}
|
|
5005
4930
|
allocationSize(value) {
|
|
5006
|
-
return
|
|
4931
|
+
return FfiConverterOptionalMapStringString.allocationSize(value.headers) + FfiConverterUInt32.allocationSize(value.rpcTimeoutMs) + FfiConverterUInt32.allocationSize(value.connectTimeoutMs);
|
|
5007
4932
|
}
|
|
5008
4933
|
}
|
|
5009
4934
|
return new FFIConverter();
|
|
5010
4935
|
})();
|
|
5011
4936
|
/**
|
|
5012
|
-
* Generated factory for {@link
|
|
4937
|
+
* Generated factory for {@link DeriveOptions} record objects.
|
|
5013
4938
|
*/
|
|
5014
|
-
const
|
|
5015
|
-
const defaults = () => ({
|
|
4939
|
+
const DeriveOptions = (() => {
|
|
4940
|
+
const defaults = () => ({});
|
|
5016
4941
|
const create = (() => {
|
|
5017
4942
|
return uniffiCreateRecord(defaults);
|
|
5018
4943
|
})();
|
|
@@ -5022,54 +4947,24 @@ const EmbedOptions = (() => {
|
|
|
5022
4947
|
defaults: () => Object.freeze(defaults())
|
|
5023
4948
|
});
|
|
5024
4949
|
})();
|
|
5025
|
-
const
|
|
4950
|
+
const FfiConverterTypeDeriveOptions = (() => {
|
|
5026
4951
|
class FFIConverter extends AbstractFfiConverterByteArray {
|
|
5027
4952
|
readFromCursor(c) {
|
|
5028
|
-
return { format:
|
|
4953
|
+
return { format: FfiConverterTypeAssetFormat.readFromCursor(c) };
|
|
5029
4954
|
}
|
|
5030
4955
|
writeIntoCursor(value, c) {
|
|
5031
|
-
|
|
4956
|
+
FfiConverterTypeAssetFormat.writeIntoCursor(value.format, c);
|
|
5032
4957
|
}
|
|
5033
4958
|
allocationSize(value) {
|
|
5034
|
-
return
|
|
4959
|
+
return FfiConverterTypeAssetFormat.allocationSize(value.format);
|
|
5035
4960
|
}
|
|
5036
4961
|
}
|
|
5037
4962
|
return new FFIConverter();
|
|
5038
4963
|
})();
|
|
5039
4964
|
/**
|
|
5040
|
-
*
|
|
5041
|
-
* remote-only delivery, and the segment comes back as bytes, so there is no output to name.
|
|
5042
|
-
*/
|
|
5043
|
-
let StreamDelivery = /* @__PURE__ */ function(StreamDelivery) {
|
|
5044
|
-
StreamDelivery[StreamDelivery["Embedded"] = 0] = "Embedded";
|
|
5045
|
-
StreamDelivery[StreamDelivery["EmbeddedAndRemote"] = 1] = "EmbeddedAndRemote";
|
|
5046
|
-
return StreamDelivery;
|
|
5047
|
-
}({});
|
|
5048
|
-
const FfiConverterTypeStreamDelivery = (() => {
|
|
5049
|
-
class FFIConverter extends AbstractFfiConverterByteArray {
|
|
5050
|
-
readFromCursor(c) {
|
|
5051
|
-
switch (c.readI32()) {
|
|
5052
|
-
case 1: return 0;
|
|
5053
|
-
case 2: return 1;
|
|
5054
|
-
default: throw new UniffiInternalError.UnexpectedEnumCase();
|
|
5055
|
-
}
|
|
5056
|
-
}
|
|
5057
|
-
writeIntoCursor(value, c) {
|
|
5058
|
-
switch (value) {
|
|
5059
|
-
case 0: return c.writeI32(1);
|
|
5060
|
-
case 1: return c.writeI32(2);
|
|
5061
|
-
}
|
|
5062
|
-
}
|
|
5063
|
-
allocationSize(value) {
|
|
5064
|
-
return 4;
|
|
5065
|
-
}
|
|
5066
|
-
}
|
|
5067
|
-
return new FFIConverter();
|
|
5068
|
-
})();
|
|
5069
|
-
/**
|
|
5070
|
-
* Generated factory for {@link RotationPolicy} record objects.
|
|
4965
|
+
* Generated factory for {@link EmbedOptions} record objects.
|
|
5071
4966
|
*/
|
|
5072
|
-
const
|
|
4967
|
+
const EmbedOptions = (() => {
|
|
5073
4968
|
const defaults = () => ({});
|
|
5074
4969
|
const create = (() => {
|
|
5075
4970
|
return uniffiCreateRecord(defaults);
|
|
@@ -5080,59 +4975,48 @@ const RotationPolicy = (() => {
|
|
|
5080
4975
|
defaults: () => Object.freeze(defaults())
|
|
5081
4976
|
});
|
|
5082
4977
|
})();
|
|
5083
|
-
const
|
|
4978
|
+
const FfiConverterTypeEmbedOptions = (() => {
|
|
5084
4979
|
class FFIConverter extends AbstractFfiConverterByteArray {
|
|
5085
4980
|
readFromCursor(c) {
|
|
5086
|
-
return {
|
|
5087
|
-
validityPeriod: FfiConverterDuration.readFromCursor(c),
|
|
5088
|
-
refreshPercent: FfiConverterUInt8.readFromCursor(c)
|
|
5089
|
-
};
|
|
4981
|
+
return { format: FfiConverterTypeAssetFormat.readFromCursor(c) };
|
|
5090
4982
|
}
|
|
5091
4983
|
writeIntoCursor(value, c) {
|
|
5092
|
-
|
|
5093
|
-
FfiConverterUInt8.writeIntoCursor(value.refreshPercent, c);
|
|
4984
|
+
FfiConverterTypeAssetFormat.writeIntoCursor(value.format, c);
|
|
5094
4985
|
}
|
|
5095
4986
|
allocationSize(value) {
|
|
5096
|
-
return
|
|
4987
|
+
return FfiConverterTypeAssetFormat.allocationSize(value.format);
|
|
5097
4988
|
}
|
|
5098
4989
|
}
|
|
5099
4990
|
return new FFIConverter();
|
|
5100
4991
|
})();
|
|
5101
4992
|
/**
|
|
5102
|
-
*
|
|
5103
|
-
*
|
|
5104
|
-
*
|
|
4993
|
+
* A soft-binding binder: how a recoverable binding is derived from an asset. Put these inside
|
|
4994
|
+
* the issuer's manifest mode to sign and index under them, and pass them in verify options to
|
|
4995
|
+
* recover. Implement it for an algorithm the SDK does not ship; the SDK's own are
|
|
4996
|
+
* [`IsccBinder`] and [`HeldBinder`].
|
|
4997
|
+
*
|
|
4998
|
+
* `derive` answers this binder's binding for `source`, or `None` when there is none.
|
|
4999
|
+
* `options.format` is how the asset's format is known. `None` and an error
|
|
5000
|
+
* mean different things: `None` is "no binding here", an error is "the question could not be
|
|
5001
|
+
* answered", so a binder that failed never reads as an unmarked asset.
|
|
5105
5002
|
*/
|
|
5106
|
-
var
|
|
5107
|
-
[uniffiTypeNameSymbol] = "
|
|
5003
|
+
var BinderImpl = class extends UniffiAbstractObject {
|
|
5004
|
+
[uniffiTypeNameSymbol] = "BinderImpl";
|
|
5108
5005
|
[destructorGuardSymbol];
|
|
5109
5006
|
[pointerLiteralSymbol];
|
|
5110
5007
|
constructor(pointer) {
|
|
5111
5008
|
super();
|
|
5112
5009
|
this[pointerLiteralSymbol] = pointer;
|
|
5113
|
-
this[destructorGuardSymbol] =
|
|
5010
|
+
this[destructorGuardSymbol] = uniffiTypeBinderImplObjectFactory.bless(pointer);
|
|
5114
5011
|
}
|
|
5115
|
-
|
|
5116
|
-
* The C2PA soft-binding algorithm list label, e.g. `io.iscc.v0`.
|
|
5117
|
-
*/
|
|
5118
|
-
alg() {
|
|
5119
|
-
const __rb = uniffiCaller.rustCall((callStatus) => {
|
|
5120
|
-
return getter().uniffi_trylimbo_sdk_issuer_fn_method_compute_alg(uniffiTypeComputeImplObjectFactory.clonePointer(this), callStatus);
|
|
5121
|
-
}, FfiConverterString.lift.bind(FfiConverterString));
|
|
5122
|
-
try {
|
|
5123
|
-
return FfiConverterString.lift(__rb);
|
|
5124
|
-
} finally {
|
|
5125
|
-
getter().rustbuffer_free(__rb);
|
|
5126
|
-
}
|
|
5127
|
-
}
|
|
5128
|
-
async compute(request, asyncOpts_) {
|
|
5012
|
+
async derive(source, options, asyncOpts_) {
|
|
5129
5013
|
const __stack = uniffiIsDebug ? (/* @__PURE__ */ new Error()).stack : void 0;
|
|
5130
5014
|
try {
|
|
5131
5015
|
return await uniffiRustCallAsync(uniffiCaller, () => {
|
|
5132
|
-
return getter().
|
|
5016
|
+
return getter().uniffi_trylimbo_sdk_issuer_fn_method_binder_derive(uniffiTypeBinderImplObjectFactory.clonePointer(this), FfiConverterTypeRangeSource.lower(source, getter().rustbuffer_alloc), FfiConverterTypeDeriveOptions.lower(options, getter().rustbuffer_alloc));
|
|
5133
5017
|
}, getter().ffi_trylimbo_sdk_issuer_rust_future_poll_rust_buffer, getter().ffi_trylimbo_sdk_issuer_rust_future_cancel_rust_buffer, getter().ffi_trylimbo_sdk_issuer_rust_future_complete_rust_buffer, getter().ffi_trylimbo_sdk_issuer_rust_future_free_rust_buffer, (__rb) => {
|
|
5134
5018
|
try {
|
|
5135
|
-
return
|
|
5019
|
+
return FfiConverterOptionalTypeSoftBinding.lift(__rb);
|
|
5136
5020
|
} finally {
|
|
5137
5021
|
getter().rustbuffer_free(__rb);
|
|
5138
5022
|
}
|
|
@@ -5145,26 +5029,26 @@ var ComputeImpl = class extends UniffiAbstractObject {
|
|
|
5145
5029
|
uniffiDestroy() {
|
|
5146
5030
|
const ptr = this[destructorGuardSymbol];
|
|
5147
5031
|
if (ptr !== void 0) {
|
|
5148
|
-
const pointer =
|
|
5149
|
-
|
|
5150
|
-
|
|
5032
|
+
const pointer = uniffiTypeBinderImplObjectFactory.pointer(this);
|
|
5033
|
+
uniffiTypeBinderImplObjectFactory.freePointer(pointer);
|
|
5034
|
+
uniffiTypeBinderImplObjectFactory.unbless(ptr);
|
|
5151
5035
|
delete this[destructorGuardSymbol];
|
|
5152
5036
|
}
|
|
5153
5037
|
}
|
|
5154
5038
|
static instanceOf(obj_) {
|
|
5155
|
-
return
|
|
5039
|
+
return uniffiTypeBinderImplObjectFactory.isConcreteType(obj_);
|
|
5156
5040
|
}
|
|
5157
5041
|
};
|
|
5158
|
-
const
|
|
5042
|
+
const uniffiTypeBinderImplObjectFactory = (() => {
|
|
5159
5043
|
const registry = typeof FinalizationRegistry !== "undefined" ? new FinalizationRegistry((heldValue) => {
|
|
5160
|
-
|
|
5044
|
+
uniffiTypeBinderImplObjectFactory.freePointer(heldValue);
|
|
5161
5045
|
}) : null;
|
|
5162
5046
|
return {
|
|
5163
5047
|
create(pointer) {
|
|
5164
|
-
const instance = Object.create(
|
|
5048
|
+
const instance = Object.create(BinderImpl.prototype);
|
|
5165
5049
|
instance[pointerLiteralSymbol] = pointer;
|
|
5166
5050
|
instance[destructorGuardSymbol] = this.bless(pointer);
|
|
5167
|
-
instance[uniffiTypeNameSymbol] = "
|
|
5051
|
+
instance[uniffiTypeNameSymbol] = "BinderImpl";
|
|
5168
5052
|
return instance;
|
|
5169
5053
|
},
|
|
5170
5054
|
bless(p) {
|
|
@@ -5184,40 +5068,26 @@ const uniffiTypeComputeImplObjectFactory = (() => {
|
|
|
5184
5068
|
},
|
|
5185
5069
|
clonePointer(obj_) {
|
|
5186
5070
|
const pointer = this.pointer(obj_);
|
|
5187
|
-
return uniffiCaller.rustCall((callStatus) => getter().
|
|
5071
|
+
return uniffiCaller.rustCall((callStatus) => getter().uniffi_trylimbo_sdk_issuer_fn_clone_binder(pointer, callStatus), FfiConverterString.lift);
|
|
5188
5072
|
},
|
|
5189
5073
|
freePointer(pointer) {
|
|
5190
|
-
uniffiCaller.rustCall((callStatus) => getter().
|
|
5074
|
+
uniffiCaller.rustCall((callStatus) => getter().uniffi_trylimbo_sdk_issuer_fn_free_binder(pointer, callStatus), FfiConverterString.lift);
|
|
5191
5075
|
},
|
|
5192
5076
|
isConcreteType(obj_) {
|
|
5193
|
-
return obj_[destructorGuardSymbol] && obj_[uniffiTypeNameSymbol] === "
|
|
5077
|
+
return obj_[destructorGuardSymbol] && obj_[uniffiTypeNameSymbol] === "BinderImpl";
|
|
5194
5078
|
}
|
|
5195
5079
|
};
|
|
5196
5080
|
})();
|
|
5197
|
-
const
|
|
5198
|
-
const
|
|
5081
|
+
const FfiConverterTypeBinder = new FfiConverterObjectWithCallbacks(uniffiTypeBinderImplObjectFactory);
|
|
5082
|
+
const uniffiCallbackInterfaceBinder = {
|
|
5199
5083
|
vtable: {
|
|
5200
|
-
|
|
5201
|
-
const uniffiMakeCall = () => {
|
|
5202
|
-
return FfiConverterTypeCompute.lift(uniffiHandle).alg();
|
|
5203
|
-
};
|
|
5204
|
-
const uniffiResult = UniffiResult.ready();
|
|
5205
|
-
const uniffiHandleSuccess = (obj) => {
|
|
5206
|
-
UniffiResult.writeSuccess(uniffiResult, FfiConverterString.lower(obj, getter().rustbuffer_alloc));
|
|
5207
|
-
};
|
|
5208
|
-
const uniffiHandleError = (code, errBuf) => {
|
|
5209
|
-
UniffiResult.writeError(uniffiResult, code, errBuf);
|
|
5210
|
-
};
|
|
5211
|
-
uniffiTraitInterfaceCall(uniffiMakeCall, uniffiHandleSuccess, uniffiHandleError, FfiConverterString.lower.bind(FfiConverterString), getter().rustbuffer_alloc);
|
|
5212
|
-
return uniffiResult;
|
|
5213
|
-
},
|
|
5214
|
-
compute: (uniffiHandle, request, uniffiFutureCallback, uniffiCallbackData) => {
|
|
5084
|
+
derive: (uniffiHandle, source, options, uniffiFutureCallback, uniffiCallbackData) => {
|
|
5215
5085
|
const uniffiMakeCall = async (signal) => {
|
|
5216
|
-
return await
|
|
5086
|
+
return await FfiConverterTypeBinder.lift(uniffiHandle).derive(FfiConverterTypeRangeSource.lift(source), FfiConverterTypeDeriveOptions.lift(options), { signal });
|
|
5217
5087
|
};
|
|
5218
5088
|
const uniffiHandleSuccess = (returnValue) => {
|
|
5219
5089
|
uniffiFutureCallback.call(uniffiFutureCallback, uniffiCallbackData, {
|
|
5220
|
-
return_value:
|
|
5090
|
+
return_value: FfiConverterOptionalTypeSoftBinding.lower(returnValue, getter().rustbuffer_alloc),
|
|
5221
5091
|
call_status: uniffiCaller.createCallStatus()
|
|
5222
5092
|
});
|
|
5223
5093
|
};
|
|
@@ -5230,130 +5100,122 @@ const uniffiCallbackInterfaceCompute = {
|
|
|
5230
5100
|
return uniffiTraitInterfaceCallAsyncWithError(uniffiMakeCall, uniffiHandleSuccess, uniffiHandleError, SdkError.instanceOf, FfiConverterTypeSdkError.lower.bind(FfiConverterTypeSdkError), FfiConverterString.lower.bind(FfiConverterString), getter().rustbuffer_alloc);
|
|
5231
5101
|
},
|
|
5232
5102
|
uniffi_free: (uniffiHandle) => {
|
|
5233
|
-
|
|
5103
|
+
FfiConverterTypeBinder.drop(uniffiHandle);
|
|
5234
5104
|
},
|
|
5235
5105
|
uniffi_clone: (uniffiHandle) => {
|
|
5236
|
-
return
|
|
5106
|
+
return FfiConverterTypeBinder.clone(uniffiHandle);
|
|
5237
5107
|
}
|
|
5238
5108
|
},
|
|
5239
5109
|
register: () => {
|
|
5240
|
-
getter().
|
|
5110
|
+
getter().uniffi_trylimbo_sdk_issuer_fn_init_callback_vtable_binder(uniffiCallbackInterfaceBinder.vtable);
|
|
5241
5111
|
}
|
|
5242
5112
|
};
|
|
5243
|
-
let
|
|
5244
|
-
|
|
5245
|
-
|
|
5246
|
-
|
|
5247
|
-
return
|
|
5113
|
+
let StreamDelivery_Tags = /* @__PURE__ */ function(StreamDelivery_Tags) {
|
|
5114
|
+
StreamDelivery_Tags["Embedded"] = "Embedded";
|
|
5115
|
+
StreamDelivery_Tags["Remote"] = "Remote";
|
|
5116
|
+
StreamDelivery_Tags["Both"] = "Both";
|
|
5117
|
+
return StreamDelivery_Tags;
|
|
5248
5118
|
}({});
|
|
5249
5119
|
/**
|
|
5250
|
-
*
|
|
5120
|
+
* How a live stream's init manifest is delivered and which binders it declares. A stream
|
|
5121
|
+
* returns its signed init segment as bytes, so there is no output to name.
|
|
5251
5122
|
*/
|
|
5252
|
-
const
|
|
5253
|
-
|
|
5254
|
-
* This SDK's own engine for `alg`, run over the asset.
|
|
5255
|
-
*/
|
|
5256
|
-
class Builtin_ extends UniffiEnum {
|
|
5123
|
+
const StreamDelivery = (() => {
|
|
5124
|
+
class Embedded_ extends UniffiEnum {
|
|
5257
5125
|
/**
|
|
5258
5126
|
* @private
|
|
5259
5127
|
* This field is private and should not be used, use `tag` instead.
|
|
5260
5128
|
*/
|
|
5261
|
-
[uniffiTypeNameSymbol] = "
|
|
5262
|
-
tag = "
|
|
5129
|
+
[uniffiTypeNameSymbol] = "StreamDelivery";
|
|
5130
|
+
tag = "Embedded";
|
|
5263
5131
|
inner;
|
|
5264
5132
|
constructor(inner) {
|
|
5265
|
-
super("
|
|
5133
|
+
super("StreamDelivery", "Embedded");
|
|
5266
5134
|
this.inner = Object.freeze(inner);
|
|
5267
5135
|
}
|
|
5268
5136
|
static new(inner) {
|
|
5269
|
-
return new
|
|
5137
|
+
return new Embedded_(inner);
|
|
5270
5138
|
}
|
|
5271
5139
|
static instanceOf(obj) {
|
|
5272
|
-
return obj.tag === "
|
|
5140
|
+
return obj.tag === "Embedded";
|
|
5273
5141
|
}
|
|
5274
5142
|
}
|
|
5275
|
-
|
|
5276
|
-
* Values already held, declared as they are; nothing reads the asset for them.
|
|
5277
|
-
*/
|
|
5278
|
-
class Held_ extends UniffiEnum {
|
|
5143
|
+
class Remote_ extends UniffiEnum {
|
|
5279
5144
|
/**
|
|
5280
5145
|
* @private
|
|
5281
5146
|
* This field is private and should not be used, use `tag` instead.
|
|
5282
5147
|
*/
|
|
5283
|
-
[uniffiTypeNameSymbol] = "
|
|
5284
|
-
tag = "
|
|
5148
|
+
[uniffiTypeNameSymbol] = "StreamDelivery";
|
|
5149
|
+
tag = "Remote";
|
|
5285
5150
|
inner;
|
|
5286
5151
|
constructor(inner) {
|
|
5287
|
-
super("
|
|
5152
|
+
super("StreamDelivery", "Remote");
|
|
5288
5153
|
this.inner = Object.freeze(inner);
|
|
5289
5154
|
}
|
|
5290
5155
|
static new(inner) {
|
|
5291
|
-
return new
|
|
5156
|
+
return new Remote_(inner);
|
|
5292
5157
|
}
|
|
5293
5158
|
static instanceOf(obj) {
|
|
5294
|
-
return obj.tag === "
|
|
5159
|
+
return obj.tag === "Remote";
|
|
5295
5160
|
}
|
|
5296
5161
|
}
|
|
5297
|
-
|
|
5298
|
-
* Your engine, run over the asset.
|
|
5299
|
-
*/
|
|
5300
|
-
class Custom_ extends UniffiEnum {
|
|
5162
|
+
class Both_ extends UniffiEnum {
|
|
5301
5163
|
/**
|
|
5302
5164
|
* @private
|
|
5303
5165
|
* This field is private and should not be used, use `tag` instead.
|
|
5304
5166
|
*/
|
|
5305
|
-
[uniffiTypeNameSymbol] = "
|
|
5306
|
-
tag = "
|
|
5167
|
+
[uniffiTypeNameSymbol] = "StreamDelivery";
|
|
5168
|
+
tag = "Both";
|
|
5307
5169
|
inner;
|
|
5308
5170
|
constructor(inner) {
|
|
5309
|
-
super("
|
|
5171
|
+
super("StreamDelivery", "Both");
|
|
5310
5172
|
this.inner = Object.freeze(inner);
|
|
5311
5173
|
}
|
|
5312
5174
|
static new(inner) {
|
|
5313
|
-
return new
|
|
5175
|
+
return new Both_(inner);
|
|
5314
5176
|
}
|
|
5315
5177
|
static instanceOf(obj) {
|
|
5316
|
-
return obj.tag === "
|
|
5178
|
+
return obj.tag === "Both";
|
|
5317
5179
|
}
|
|
5318
5180
|
}
|
|
5319
5181
|
function instanceOf(obj) {
|
|
5320
|
-
return obj[uniffiTypeNameSymbol] === "
|
|
5182
|
+
return obj[uniffiTypeNameSymbol] === "StreamDelivery";
|
|
5321
5183
|
}
|
|
5322
5184
|
return Object.freeze({
|
|
5323
5185
|
instanceOf,
|
|
5324
|
-
|
|
5325
|
-
|
|
5326
|
-
|
|
5186
|
+
Embedded: Embedded_,
|
|
5187
|
+
Remote: Remote_,
|
|
5188
|
+
Both: Both_
|
|
5327
5189
|
});
|
|
5328
5190
|
})();
|
|
5329
|
-
const
|
|
5191
|
+
const FfiConverterTypeStreamDelivery = (() => {
|
|
5330
5192
|
class FFIConverter extends AbstractFfiConverterByteArray {
|
|
5331
5193
|
readFromCursor(c) {
|
|
5332
5194
|
switch (c.readI32()) {
|
|
5333
|
-
case 1: return new
|
|
5334
|
-
case 2: return new
|
|
5335
|
-
case 3: return new
|
|
5195
|
+
case 1: return new StreamDelivery.Embedded({ binders: FfiConverterSequenceTypeBinder.readFromCursor(c) });
|
|
5196
|
+
case 2: return new StreamDelivery.Remote({ binders: FfiConverterSequenceTypeBinder.readFromCursor(c) });
|
|
5197
|
+
case 3: return new StreamDelivery.Both({ binders: FfiConverterSequenceTypeBinder.readFromCursor(c) });
|
|
5336
5198
|
default: throw new UniffiInternalError.UnexpectedEnumCase();
|
|
5337
5199
|
}
|
|
5338
5200
|
}
|
|
5339
5201
|
writeIntoCursor(value, c) {
|
|
5340
5202
|
switch (value.tag) {
|
|
5341
|
-
case "
|
|
5203
|
+
case "Embedded": {
|
|
5342
5204
|
c.writeI32(1);
|
|
5343
5205
|
const inner = value.inner;
|
|
5344
|
-
|
|
5206
|
+
FfiConverterSequenceTypeBinder.writeIntoCursor(inner.binders, c);
|
|
5345
5207
|
return;
|
|
5346
5208
|
}
|
|
5347
|
-
case "
|
|
5209
|
+
case "Remote": {
|
|
5348
5210
|
c.writeI32(2);
|
|
5349
5211
|
const inner = value.inner;
|
|
5350
|
-
|
|
5212
|
+
FfiConverterSequenceTypeBinder.writeIntoCursor(inner.binders, c);
|
|
5351
5213
|
return;
|
|
5352
5214
|
}
|
|
5353
|
-
case "
|
|
5215
|
+
case "Both": {
|
|
5354
5216
|
c.writeI32(3);
|
|
5355
5217
|
const inner = value.inner;
|
|
5356
|
-
|
|
5218
|
+
FfiConverterSequenceTypeBinder.writeIntoCursor(inner.binders, c);
|
|
5357
5219
|
return;
|
|
5358
5220
|
}
|
|
5359
5221
|
default: throw new UniffiInternalError.UnexpectedEnumCase();
|
|
@@ -5361,22 +5223,22 @@ const FfiConverterTypeSoftBindingSource = (() => {
|
|
|
5361
5223
|
}
|
|
5362
5224
|
allocationSize(value) {
|
|
5363
5225
|
switch (value.tag) {
|
|
5364
|
-
case "
|
|
5226
|
+
case "Embedded": {
|
|
5365
5227
|
const inner = value.inner;
|
|
5366
5228
|
let size = 4;
|
|
5367
|
-
size +=
|
|
5229
|
+
size += FfiConverterSequenceTypeBinder.allocationSize(inner.binders);
|
|
5368
5230
|
return size;
|
|
5369
5231
|
}
|
|
5370
|
-
case "
|
|
5232
|
+
case "Remote": {
|
|
5371
5233
|
const inner = value.inner;
|
|
5372
5234
|
let size = 4;
|
|
5373
|
-
size +=
|
|
5235
|
+
size += FfiConverterSequenceTypeBinder.allocationSize(inner.binders);
|
|
5374
5236
|
return size;
|
|
5375
5237
|
}
|
|
5376
|
-
case "
|
|
5238
|
+
case "Both": {
|
|
5377
5239
|
const inner = value.inner;
|
|
5378
5240
|
let size = 4;
|
|
5379
|
-
size +=
|
|
5241
|
+
size += FfiConverterSequenceTypeBinder.allocationSize(inner.binders);
|
|
5380
5242
|
return size;
|
|
5381
5243
|
}
|
|
5382
5244
|
default: throw new UniffiInternalError.UnexpectedEnumCase();
|
|
@@ -5386,10 +5248,42 @@ const FfiConverterTypeSoftBindingSource = (() => {
|
|
|
5386
5248
|
return new FFIConverter();
|
|
5387
5249
|
})();
|
|
5388
5250
|
/**
|
|
5251
|
+
* Generated factory for {@link RotationPolicy} record objects.
|
|
5252
|
+
*/
|
|
5253
|
+
const RotationPolicy = (() => {
|
|
5254
|
+
const defaults = () => ({});
|
|
5255
|
+
const create = (() => {
|
|
5256
|
+
return uniffiCreateRecord(defaults);
|
|
5257
|
+
})();
|
|
5258
|
+
return Object.freeze({
|
|
5259
|
+
create,
|
|
5260
|
+
new: create,
|
|
5261
|
+
defaults: () => Object.freeze(defaults())
|
|
5262
|
+
});
|
|
5263
|
+
})();
|
|
5264
|
+
const FfiConverterTypeRotationPolicy = (() => {
|
|
5265
|
+
class FFIConverter extends AbstractFfiConverterByteArray {
|
|
5266
|
+
readFromCursor(c) {
|
|
5267
|
+
return {
|
|
5268
|
+
validityPeriodSecs: FfiConverterUInt32.readFromCursor(c),
|
|
5269
|
+
refreshPercent: FfiConverterUInt8.readFromCursor(c)
|
|
5270
|
+
};
|
|
5271
|
+
}
|
|
5272
|
+
writeIntoCursor(value, c) {
|
|
5273
|
+
FfiConverterUInt32.writeIntoCursor(value.validityPeriodSecs, c);
|
|
5274
|
+
FfiConverterUInt8.writeIntoCursor(value.refreshPercent, c);
|
|
5275
|
+
}
|
|
5276
|
+
allocationSize(value) {
|
|
5277
|
+
return FfiConverterUInt32.allocationSize(value.validityPeriodSecs) + FfiConverterUInt8.allocationSize(value.refreshPercent);
|
|
5278
|
+
}
|
|
5279
|
+
}
|
|
5280
|
+
return new FFIConverter();
|
|
5281
|
+
})();
|
|
5282
|
+
/**
|
|
5389
5283
|
* Generated factory for {@link InitOptions} record objects.
|
|
5390
5284
|
*/
|
|
5391
5285
|
const InitOptions = (() => {
|
|
5392
|
-
const defaults = () => ({
|
|
5286
|
+
const defaults = () => ({});
|
|
5393
5287
|
const create = (() => {
|
|
5394
5288
|
return uniffiCreateRecord(defaults);
|
|
5395
5289
|
})();
|
|
@@ -5404,17 +5298,15 @@ const FfiConverterTypeInitOptions = (() => {
|
|
|
5404
5298
|
readFromCursor(c) {
|
|
5405
5299
|
return {
|
|
5406
5300
|
delivery: FfiConverterTypeStreamDelivery.readFromCursor(c),
|
|
5407
|
-
rotationPolicy: FfiConverterTypeRotationPolicy.readFromCursor(c)
|
|
5408
|
-
softBindings: FfiConverterSequenceTypeSoftBindingSource.readFromCursor(c)
|
|
5301
|
+
rotationPolicy: FfiConverterTypeRotationPolicy.readFromCursor(c)
|
|
5409
5302
|
};
|
|
5410
5303
|
}
|
|
5411
5304
|
writeIntoCursor(value, c) {
|
|
5412
5305
|
FfiConverterTypeStreamDelivery.writeIntoCursor(value.delivery, c);
|
|
5413
5306
|
FfiConverterTypeRotationPolicy.writeIntoCursor(value.rotationPolicy, c);
|
|
5414
|
-
FfiConverterSequenceTypeSoftBindingSource.writeIntoCursor(value.softBindings, c);
|
|
5415
5307
|
}
|
|
5416
5308
|
allocationSize(value) {
|
|
5417
|
-
return FfiConverterTypeStreamDelivery.allocationSize(value.delivery) + FfiConverterTypeRotationPolicy.allocationSize(value.rotationPolicy)
|
|
5309
|
+
return FfiConverterTypeStreamDelivery.allocationSize(value.delivery) + FfiConverterTypeRotationPolicy.allocationSize(value.rotationPolicy);
|
|
5418
5310
|
}
|
|
5419
5311
|
}
|
|
5420
5312
|
return new FFIConverter();
|
|
@@ -5437,16 +5329,16 @@ const FfiConverterTypeInitOutcome = (() => {
|
|
|
5437
5329
|
class FFIConverter extends AbstractFfiConverterByteArray {
|
|
5438
5330
|
readFromCursor(c) {
|
|
5439
5331
|
return {
|
|
5440
|
-
|
|
5441
|
-
|
|
5332
|
+
signedInitBytes: FfiConverterArrayBuffer.readFromCursor(c),
|
|
5333
|
+
validUntilEpochSecs: FfiConverterInt64.readFromCursor(c)
|
|
5442
5334
|
};
|
|
5443
5335
|
}
|
|
5444
5336
|
writeIntoCursor(value, c) {
|
|
5445
|
-
FfiConverterArrayBuffer.writeIntoCursor(value.
|
|
5446
|
-
|
|
5337
|
+
FfiConverterArrayBuffer.writeIntoCursor(value.signedInitBytes, c);
|
|
5338
|
+
FfiConverterInt64.writeIntoCursor(value.validUntilEpochSecs, c);
|
|
5447
5339
|
}
|
|
5448
5340
|
allocationSize(value) {
|
|
5449
|
-
return FfiConverterArrayBuffer.allocationSize(value.
|
|
5341
|
+
return FfiConverterArrayBuffer.allocationSize(value.signedInitBytes) + FfiConverterInt64.allocationSize(value.validUntilEpochSecs);
|
|
5450
5342
|
}
|
|
5451
5343
|
}
|
|
5452
5344
|
return new FFIConverter();
|
|
@@ -5455,10 +5347,7 @@ const FfiConverterTypeInitOutcome = (() => {
|
|
|
5455
5347
|
* Generated factory for {@link MarkOptions} record objects.
|
|
5456
5348
|
*/
|
|
5457
5349
|
const MarkOptions = (() => {
|
|
5458
|
-
const defaults = () => ({
|
|
5459
|
-
format: void 0,
|
|
5460
|
-
algorithms: []
|
|
5461
|
-
});
|
|
5350
|
+
const defaults = () => ({});
|
|
5462
5351
|
const create = (() => {
|
|
5463
5352
|
return uniffiCreateRecord(defaults);
|
|
5464
5353
|
})();
|
|
@@ -5472,16 +5361,18 @@ const FfiConverterTypeMarkOptions = (() => {
|
|
|
5472
5361
|
class FFIConverter extends AbstractFfiConverterByteArray {
|
|
5473
5362
|
readFromCursor(c) {
|
|
5474
5363
|
return {
|
|
5475
|
-
format:
|
|
5476
|
-
|
|
5364
|
+
format: FfiConverterTypeAssetFormat.readFromCursor(c),
|
|
5365
|
+
fileName: FfiConverterString.readFromCursor(c),
|
|
5366
|
+
signpost: FfiConverterBool.readFromCursor(c)
|
|
5477
5367
|
};
|
|
5478
5368
|
}
|
|
5479
5369
|
writeIntoCursor(value, c) {
|
|
5480
|
-
|
|
5481
|
-
|
|
5370
|
+
FfiConverterTypeAssetFormat.writeIntoCursor(value.format, c);
|
|
5371
|
+
FfiConverterString.writeIntoCursor(value.fileName, c);
|
|
5372
|
+
FfiConverterBool.writeIntoCursor(value.signpost, c);
|
|
5482
5373
|
}
|
|
5483
5374
|
allocationSize(value) {
|
|
5484
|
-
return
|
|
5375
|
+
return FfiConverterTypeAssetFormat.allocationSize(value.format) + FfiConverterString.allocationSize(value.fileName) + FfiConverterBool.allocationSize(value.signpost);
|
|
5485
5376
|
}
|
|
5486
5377
|
}
|
|
5487
5378
|
return new FFIConverter();
|
|
@@ -5504,24 +5395,28 @@ const FfiConverterTypeMarkOutcome = (() => {
|
|
|
5504
5395
|
class FFIConverter extends AbstractFfiConverterByteArray {
|
|
5505
5396
|
readFromCursor(c) {
|
|
5506
5397
|
return {
|
|
5398
|
+
bytes: FfiConverterArrayBuffer.readFromCursor(c),
|
|
5507
5399
|
format: FfiConverterString.readFromCursor(c),
|
|
5400
|
+
fileName: FfiConverterString.readFromCursor(c),
|
|
5508
5401
|
actions: FfiConverterSequenceTypeAction.readFromCursor(c)
|
|
5509
5402
|
};
|
|
5510
5403
|
}
|
|
5511
5404
|
writeIntoCursor(value, c) {
|
|
5405
|
+
FfiConverterArrayBuffer.writeIntoCursor(value.bytes, c);
|
|
5512
5406
|
FfiConverterString.writeIntoCursor(value.format, c);
|
|
5407
|
+
FfiConverterString.writeIntoCursor(value.fileName, c);
|
|
5513
5408
|
FfiConverterSequenceTypeAction.writeIntoCursor(value.actions, c);
|
|
5514
5409
|
}
|
|
5515
5410
|
allocationSize(value) {
|
|
5516
|
-
return FfiConverterString.allocationSize(value.format) + FfiConverterSequenceTypeAction.allocationSize(value.actions);
|
|
5411
|
+
return FfiConverterArrayBuffer.allocationSize(value.bytes) + FfiConverterString.allocationSize(value.format) + FfiConverterString.allocationSize(value.fileName) + FfiConverterSequenceTypeAction.allocationSize(value.actions);
|
|
5517
5412
|
}
|
|
5518
5413
|
}
|
|
5519
5414
|
return new FFIConverter();
|
|
5520
5415
|
})();
|
|
5521
5416
|
/**
|
|
5522
|
-
* Generated factory for {@link
|
|
5417
|
+
* Generated factory for {@link Region} record objects.
|
|
5523
5418
|
*/
|
|
5524
|
-
const
|
|
5419
|
+
const Region = (() => {
|
|
5525
5420
|
const defaults = () => ({});
|
|
5526
5421
|
const create = (() => {
|
|
5527
5422
|
return uniffiCreateRecord(defaults);
|
|
@@ -5532,16 +5427,20 @@ const MintRequest = (() => {
|
|
|
5532
5427
|
defaults: () => Object.freeze(defaults())
|
|
5533
5428
|
});
|
|
5534
5429
|
})();
|
|
5535
|
-
const
|
|
5430
|
+
const FfiConverterTypeRegion = (() => {
|
|
5536
5431
|
class FFIConverter extends AbstractFfiConverterByteArray {
|
|
5537
5432
|
readFromCursor(c) {
|
|
5538
|
-
return {
|
|
5433
|
+
return {
|
|
5434
|
+
offset: FfiConverterUInt64.readFromCursor(c),
|
|
5435
|
+
length: FfiConverterUInt64.readFromCursor(c)
|
|
5436
|
+
};
|
|
5539
5437
|
}
|
|
5540
5438
|
writeIntoCursor(value, c) {
|
|
5541
|
-
|
|
5439
|
+
FfiConverterUInt64.writeIntoCursor(value.offset, c);
|
|
5440
|
+
FfiConverterUInt64.writeIntoCursor(value.length, c);
|
|
5542
5441
|
}
|
|
5543
5442
|
allocationSize(value) {
|
|
5544
|
-
return
|
|
5443
|
+
return FfiConverterUInt64.allocationSize(value.offset) + FfiConverterUInt64.allocationSize(value.length);
|
|
5545
5444
|
}
|
|
5546
5445
|
}
|
|
5547
5446
|
return new FFIConverter();
|
|
@@ -5566,48 +5465,16 @@ const FfiConverterTypeSegmentOutcome = (() => {
|
|
|
5566
5465
|
return {
|
|
5567
5466
|
bytes: FfiConverterArrayBuffer.readFromCursor(c),
|
|
5568
5467
|
rotationDue: FfiConverterBool.readFromCursor(c),
|
|
5569
|
-
|
|
5468
|
+
validUntilEpochSecs: FfiConverterInt64.readFromCursor(c)
|
|
5570
5469
|
};
|
|
5571
5470
|
}
|
|
5572
5471
|
writeIntoCursor(value, c) {
|
|
5573
5472
|
FfiConverterArrayBuffer.writeIntoCursor(value.bytes, c);
|
|
5574
5473
|
FfiConverterBool.writeIntoCursor(value.rotationDue, c);
|
|
5575
|
-
|
|
5474
|
+
FfiConverterInt64.writeIntoCursor(value.validUntilEpochSecs, c);
|
|
5576
5475
|
}
|
|
5577
5476
|
allocationSize(value) {
|
|
5578
|
-
return FfiConverterArrayBuffer.allocationSize(value.bytes) + FfiConverterBool.allocationSize(value.rotationDue) +
|
|
5579
|
-
}
|
|
5580
|
-
}
|
|
5581
|
-
return new FFIConverter();
|
|
5582
|
-
})();
|
|
5583
|
-
/**
|
|
5584
|
-
* Generated factory for {@link SessionKey} record objects.
|
|
5585
|
-
*/
|
|
5586
|
-
const SessionKey = (() => {
|
|
5587
|
-
const defaults = () => ({});
|
|
5588
|
-
const create = (() => {
|
|
5589
|
-
return uniffiCreateRecord(defaults);
|
|
5590
|
-
})();
|
|
5591
|
-
return Object.freeze({
|
|
5592
|
-
create,
|
|
5593
|
-
new: create,
|
|
5594
|
-
defaults: () => Object.freeze(defaults())
|
|
5595
|
-
});
|
|
5596
|
-
})();
|
|
5597
|
-
const FfiConverterTypeSessionKey = (() => {
|
|
5598
|
-
class FFIConverter extends AbstractFfiConverterByteArray {
|
|
5599
|
-
readFromCursor(c) {
|
|
5600
|
-
return {
|
|
5601
|
-
kid: FfiConverterArrayBuffer.readFromCursor(c),
|
|
5602
|
-
publicKey: FfiConverterArrayBuffer.readFromCursor(c)
|
|
5603
|
-
};
|
|
5604
|
-
}
|
|
5605
|
-
writeIntoCursor(value, c) {
|
|
5606
|
-
FfiConverterArrayBuffer.writeIntoCursor(value.kid, c);
|
|
5607
|
-
FfiConverterArrayBuffer.writeIntoCursor(value.publicKey, c);
|
|
5608
|
-
}
|
|
5609
|
-
allocationSize(value) {
|
|
5610
|
-
return FfiConverterArrayBuffer.allocationSize(value.kid) + FfiConverterArrayBuffer.allocationSize(value.publicKey);
|
|
5477
|
+
return FfiConverterArrayBuffer.allocationSize(value.bytes) + FfiConverterBool.allocationSize(value.rotationDue) + FfiConverterInt64.allocationSize(value.validUntilEpochSecs);
|
|
5611
5478
|
}
|
|
5612
5479
|
}
|
|
5613
5480
|
return new FFIConverter();
|
|
@@ -5814,9 +5681,10 @@ let SignOutput_Tags = /* @__PURE__ */ function(SignOutput_Tags) {
|
|
|
5814
5681
|
return SignOutput_Tags;
|
|
5815
5682
|
}({});
|
|
5816
5683
|
/**
|
|
5817
|
-
* What a `sign` hands back beyond the sidecar it always returns: the sidecar alone, or the
|
|
5818
|
-
* signed asset written
|
|
5819
|
-
* [`SignOutput`](
|
|
5684
|
+
* What a `sign` hands back beyond the sidecar it always returns: the sidecar alone, or the
|
|
5685
|
+
* signed asset written through `into` in the same call. See the core
|
|
5686
|
+
* [`SignOutput`](crate::manifest::spec::SignOutput) for what pointing `into` at the asset's own
|
|
5687
|
+
* storage means.
|
|
5820
5688
|
*/
|
|
5821
5689
|
const SignOutput = (() => {
|
|
5822
5690
|
class Sidecar_ extends UniffiEnum {
|
|
@@ -5905,15 +5773,16 @@ const FfiConverterTypeSignOutput = (() => {
|
|
|
5905
5773
|
let AssetDelivery_Tags = /* @__PURE__ */ function(AssetDelivery_Tags) {
|
|
5906
5774
|
AssetDelivery_Tags["Embedded"] = "Embedded";
|
|
5907
5775
|
AssetDelivery_Tags["Remote"] = "Remote";
|
|
5908
|
-
AssetDelivery_Tags["
|
|
5776
|
+
AssetDelivery_Tags["Both"] = "Both";
|
|
5909
5777
|
return AssetDelivery_Tags;
|
|
5910
5778
|
}({});
|
|
5911
5779
|
/**
|
|
5912
|
-
*
|
|
5780
|
+
* How a static asset's manifest is delivered, which binders it declares, and what comes back.
|
|
5913
5781
|
*
|
|
5914
|
-
* Embedded manifests
|
|
5915
|
-
*
|
|
5916
|
-
* asset, so it names no output
|
|
5782
|
+
* Embedded manifests may still need bindings, for example to describe a bound watermark, but
|
|
5783
|
+
* are not indexed. Remote needs at least one resolved binding, from a binder or a bound
|
|
5784
|
+
* watermark action, and never touches the asset, so it names no output; both is recoverable
|
|
5785
|
+
* through its embedded manifest and permits an empty strategy list.
|
|
5917
5786
|
*/
|
|
5918
5787
|
const AssetDelivery = (() => {
|
|
5919
5788
|
class Embedded_ extends UniffiEnum {
|
|
@@ -5942,33 +5811,35 @@ const AssetDelivery = (() => {
|
|
|
5942
5811
|
*/
|
|
5943
5812
|
[uniffiTypeNameSymbol] = "AssetDelivery";
|
|
5944
5813
|
tag = "Remote";
|
|
5945
|
-
|
|
5814
|
+
inner;
|
|
5815
|
+
constructor(inner) {
|
|
5946
5816
|
super("AssetDelivery", "Remote");
|
|
5817
|
+
this.inner = Object.freeze(inner);
|
|
5947
5818
|
}
|
|
5948
|
-
static new() {
|
|
5949
|
-
return new Remote_();
|
|
5819
|
+
static new(inner) {
|
|
5820
|
+
return new Remote_(inner);
|
|
5950
5821
|
}
|
|
5951
5822
|
static instanceOf(obj) {
|
|
5952
5823
|
return obj.tag === "Remote";
|
|
5953
5824
|
}
|
|
5954
5825
|
}
|
|
5955
|
-
class
|
|
5826
|
+
class Both_ extends UniffiEnum {
|
|
5956
5827
|
/**
|
|
5957
5828
|
* @private
|
|
5958
5829
|
* This field is private and should not be used, use `tag` instead.
|
|
5959
5830
|
*/
|
|
5960
5831
|
[uniffiTypeNameSymbol] = "AssetDelivery";
|
|
5961
|
-
tag = "
|
|
5832
|
+
tag = "Both";
|
|
5962
5833
|
inner;
|
|
5963
5834
|
constructor(inner) {
|
|
5964
|
-
super("AssetDelivery", "
|
|
5835
|
+
super("AssetDelivery", "Both");
|
|
5965
5836
|
this.inner = Object.freeze(inner);
|
|
5966
5837
|
}
|
|
5967
5838
|
static new(inner) {
|
|
5968
|
-
return new
|
|
5839
|
+
return new Both_(inner);
|
|
5969
5840
|
}
|
|
5970
5841
|
static instanceOf(obj) {
|
|
5971
|
-
return obj.tag === "
|
|
5842
|
+
return obj.tag === "Both";
|
|
5972
5843
|
}
|
|
5973
5844
|
}
|
|
5974
5845
|
function instanceOf(obj) {
|
|
@@ -5978,16 +5849,22 @@ const AssetDelivery = (() => {
|
|
|
5978
5849
|
instanceOf,
|
|
5979
5850
|
Embedded: Embedded_,
|
|
5980
5851
|
Remote: Remote_,
|
|
5981
|
-
|
|
5852
|
+
Both: Both_
|
|
5982
5853
|
});
|
|
5983
5854
|
})();
|
|
5984
5855
|
const FfiConverterTypeAssetDelivery = (() => {
|
|
5985
5856
|
class FFIConverter extends AbstractFfiConverterByteArray {
|
|
5986
5857
|
readFromCursor(c) {
|
|
5987
5858
|
switch (c.readI32()) {
|
|
5988
|
-
case 1: return new AssetDelivery.Embedded({
|
|
5989
|
-
|
|
5990
|
-
|
|
5859
|
+
case 1: return new AssetDelivery.Embedded({
|
|
5860
|
+
binders: FfiConverterSequenceTypeBinder.readFromCursor(c),
|
|
5861
|
+
output: FfiConverterTypeSignOutput.readFromCursor(c)
|
|
5862
|
+
});
|
|
5863
|
+
case 2: return new AssetDelivery.Remote({ binders: FfiConverterSequenceTypeBinder.readFromCursor(c) });
|
|
5864
|
+
case 3: return new AssetDelivery.Both({
|
|
5865
|
+
binders: FfiConverterSequenceTypeBinder.readFromCursor(c),
|
|
5866
|
+
output: FfiConverterTypeSignOutput.readFromCursor(c)
|
|
5867
|
+
});
|
|
5991
5868
|
default: throw new UniffiInternalError.UnexpectedEnumCase();
|
|
5992
5869
|
}
|
|
5993
5870
|
}
|
|
@@ -5996,15 +5873,20 @@ const FfiConverterTypeAssetDelivery = (() => {
|
|
|
5996
5873
|
case "Embedded": {
|
|
5997
5874
|
c.writeI32(1);
|
|
5998
5875
|
const inner = value.inner;
|
|
5876
|
+
FfiConverterSequenceTypeBinder.writeIntoCursor(inner.binders, c);
|
|
5999
5877
|
FfiConverterTypeSignOutput.writeIntoCursor(inner.output, c);
|
|
6000
5878
|
return;
|
|
6001
5879
|
}
|
|
6002
|
-
case "Remote":
|
|
5880
|
+
case "Remote": {
|
|
6003
5881
|
c.writeI32(2);
|
|
5882
|
+
const inner = value.inner;
|
|
5883
|
+
FfiConverterSequenceTypeBinder.writeIntoCursor(inner.binders, c);
|
|
6004
5884
|
return;
|
|
6005
|
-
|
|
5885
|
+
}
|
|
5886
|
+
case "Both": {
|
|
6006
5887
|
c.writeI32(3);
|
|
6007
5888
|
const inner = value.inner;
|
|
5889
|
+
FfiConverterSequenceTypeBinder.writeIntoCursor(inner.binders, c);
|
|
6008
5890
|
FfiConverterTypeSignOutput.writeIntoCursor(inner.output, c);
|
|
6009
5891
|
return;
|
|
6010
5892
|
}
|
|
@@ -6016,13 +5898,20 @@ const FfiConverterTypeAssetDelivery = (() => {
|
|
|
6016
5898
|
case "Embedded": {
|
|
6017
5899
|
const inner = value.inner;
|
|
6018
5900
|
let size = 4;
|
|
5901
|
+
size += FfiConverterSequenceTypeBinder.allocationSize(inner.binders);
|
|
6019
5902
|
size += FfiConverterTypeSignOutput.allocationSize(inner.output);
|
|
6020
5903
|
return size;
|
|
6021
5904
|
}
|
|
6022
|
-
case "Remote":
|
|
6023
|
-
case "EmbeddedAndRemote": {
|
|
5905
|
+
case "Remote": {
|
|
6024
5906
|
const inner = value.inner;
|
|
6025
5907
|
let size = 4;
|
|
5908
|
+
size += FfiConverterSequenceTypeBinder.allocationSize(inner.binders);
|
|
5909
|
+
return size;
|
|
5910
|
+
}
|
|
5911
|
+
case "Both": {
|
|
5912
|
+
const inner = value.inner;
|
|
5913
|
+
let size = 4;
|
|
5914
|
+
size += FfiConverterSequenceTypeBinder.allocationSize(inner.binders);
|
|
6026
5915
|
size += FfiConverterTypeSignOutput.allocationSize(inner.output);
|
|
6027
5916
|
return size;
|
|
6028
5917
|
}
|
|
@@ -6036,11 +5925,7 @@ const FfiConverterTypeAssetDelivery = (() => {
|
|
|
6036
5925
|
* Generated factory for {@link SignOptions} record objects.
|
|
6037
5926
|
*/
|
|
6038
5927
|
const SignOptions = (() => {
|
|
6039
|
-
const defaults = () => ({
|
|
6040
|
-
format: void 0,
|
|
6041
|
-
thumbnail: void 0,
|
|
6042
|
-
softBindings: []
|
|
6043
|
-
});
|
|
5928
|
+
const defaults = () => ({ thumbnail: void 0 });
|
|
6044
5929
|
const create = (() => {
|
|
6045
5930
|
return uniffiCreateRecord(defaults);
|
|
6046
5931
|
})();
|
|
@@ -6055,19 +5940,17 @@ const FfiConverterTypeSignOptions = (() => {
|
|
|
6055
5940
|
readFromCursor(c) {
|
|
6056
5941
|
return {
|
|
6057
5942
|
delivery: FfiConverterTypeAssetDelivery.readFromCursor(c),
|
|
6058
|
-
format:
|
|
6059
|
-
thumbnail: FfiConverterOptionalTypeThumbnail.readFromCursor(c)
|
|
6060
|
-
softBindings: FfiConverterSequenceTypeSoftBindingSource.readFromCursor(c)
|
|
5943
|
+
format: FfiConverterTypeAssetFormat.readFromCursor(c),
|
|
5944
|
+
thumbnail: FfiConverterOptionalTypeThumbnail.readFromCursor(c)
|
|
6061
5945
|
};
|
|
6062
5946
|
}
|
|
6063
5947
|
writeIntoCursor(value, c) {
|
|
6064
5948
|
FfiConverterTypeAssetDelivery.writeIntoCursor(value.delivery, c);
|
|
6065
|
-
|
|
5949
|
+
FfiConverterTypeAssetFormat.writeIntoCursor(value.format, c);
|
|
6066
5950
|
FfiConverterOptionalTypeThumbnail.writeIntoCursor(value.thumbnail, c);
|
|
6067
|
-
FfiConverterSequenceTypeSoftBindingSource.writeIntoCursor(value.softBindings, c);
|
|
6068
5951
|
}
|
|
6069
5952
|
allocationSize(value) {
|
|
6070
|
-
return FfiConverterTypeAssetDelivery.allocationSize(value.delivery) +
|
|
5953
|
+
return FfiConverterTypeAssetDelivery.allocationSize(value.delivery) + FfiConverterTypeAssetFormat.allocationSize(value.format) + FfiConverterOptionalTypeThumbnail.allocationSize(value.thumbnail);
|
|
6071
5954
|
}
|
|
6072
5955
|
}
|
|
6073
5956
|
return new FFIConverter();
|
|
@@ -6104,25 +5987,25 @@ const FfiConverterTypeSignOutcome = (() => {
|
|
|
6104
5987
|
}
|
|
6105
5988
|
return new FFIConverter();
|
|
6106
5989
|
})();
|
|
6107
|
-
let
|
|
6108
|
-
|
|
6109
|
-
|
|
6110
|
-
return
|
|
5990
|
+
let Origin_Tags = /* @__PURE__ */ function(Origin_Tags) {
|
|
5991
|
+
Origin_Tags["Created"] = "Created";
|
|
5992
|
+
Origin_Tags["Opened"] = "Opened";
|
|
5993
|
+
return Origin_Tags;
|
|
6111
5994
|
}({});
|
|
6112
5995
|
/**
|
|
6113
|
-
* An origin a stream states; see the core [`provenance::
|
|
5996
|
+
* An origin a live stream states; see the core [`provenance::Origin`].
|
|
6114
5997
|
*/
|
|
6115
|
-
const
|
|
5998
|
+
const Origin = (() => {
|
|
6116
5999
|
class Created_ extends UniffiEnum {
|
|
6117
6000
|
/**
|
|
6118
6001
|
* @private
|
|
6119
6002
|
* This field is private and should not be used, use `tag` instead.
|
|
6120
6003
|
*/
|
|
6121
|
-
[uniffiTypeNameSymbol] = "
|
|
6004
|
+
[uniffiTypeNameSymbol] = "Origin";
|
|
6122
6005
|
tag = "Created";
|
|
6123
6006
|
inner;
|
|
6124
6007
|
constructor(v0) {
|
|
6125
|
-
super("
|
|
6008
|
+
super("Origin", "Created");
|
|
6126
6009
|
this.inner = Object.freeze([v0]);
|
|
6127
6010
|
}
|
|
6128
6011
|
static new(v0) {
|
|
@@ -6137,11 +6020,11 @@ const StreamOrigin = (() => {
|
|
|
6137
6020
|
* @private
|
|
6138
6021
|
* This field is private and should not be used, use `tag` instead.
|
|
6139
6022
|
*/
|
|
6140
|
-
[uniffiTypeNameSymbol] = "
|
|
6023
|
+
[uniffiTypeNameSymbol] = "Origin";
|
|
6141
6024
|
tag = "Opened";
|
|
6142
6025
|
inner;
|
|
6143
6026
|
constructor(v0) {
|
|
6144
|
-
super("
|
|
6027
|
+
super("Origin", "Opened");
|
|
6145
6028
|
this.inner = Object.freeze([v0]);
|
|
6146
6029
|
}
|
|
6147
6030
|
static new(v0) {
|
|
@@ -6152,7 +6035,7 @@ const StreamOrigin = (() => {
|
|
|
6152
6035
|
}
|
|
6153
6036
|
}
|
|
6154
6037
|
function instanceOf(obj) {
|
|
6155
|
-
return obj[uniffiTypeNameSymbol] === "
|
|
6038
|
+
return obj[uniffiTypeNameSymbol] === "Origin";
|
|
6156
6039
|
}
|
|
6157
6040
|
return Object.freeze({
|
|
6158
6041
|
instanceOf,
|
|
@@ -6160,12 +6043,12 @@ const StreamOrigin = (() => {
|
|
|
6160
6043
|
Opened: Opened_
|
|
6161
6044
|
});
|
|
6162
6045
|
})();
|
|
6163
|
-
const
|
|
6046
|
+
const FfiConverterTypeOrigin = (() => {
|
|
6164
6047
|
class FFIConverter extends AbstractFfiConverterByteArray {
|
|
6165
6048
|
readFromCursor(c) {
|
|
6166
6049
|
switch (c.readI32()) {
|
|
6167
|
-
case 1: return new
|
|
6168
|
-
case 2: return new
|
|
6050
|
+
case 1: return new Origin.Created(FfiConverterTypeCreatedOrigin.readFromCursor(c));
|
|
6051
|
+
case 2: return new Origin.Opened(FfiConverterTypeOpenedOrigin.readFromCursor(c));
|
|
6169
6052
|
default: throw new UniffiInternalError.UnexpectedEnumCase();
|
|
6170
6053
|
}
|
|
6171
6054
|
}
|
|
@@ -6212,10 +6095,7 @@ const FfiConverterTypeStreamOrigin = (() => {
|
|
|
6212
6095
|
const StreamManifestSpec = (() => {
|
|
6213
6096
|
const defaults = () => ({
|
|
6214
6097
|
title: void 0,
|
|
6215
|
-
|
|
6216
|
-
identity: void 0,
|
|
6217
|
-
assertions: [],
|
|
6218
|
-
components: /* @__PURE__ */ new Map()
|
|
6098
|
+
identity: void 0
|
|
6219
6099
|
});
|
|
6220
6100
|
const create = (() => {
|
|
6221
6101
|
return uniffiCreateRecord(defaults);
|
|
@@ -6231,34 +6111,33 @@ const FfiConverterTypeStreamManifestSpec = (() => {
|
|
|
6231
6111
|
readFromCursor(c) {
|
|
6232
6112
|
return {
|
|
6233
6113
|
title: FfiConverterOptionalString.readFromCursor(c),
|
|
6234
|
-
origin:
|
|
6114
|
+
origin: FfiConverterTypeOrigin.readFromCursor(c),
|
|
6235
6115
|
actions: FfiConverterSequenceTypeAction.readFromCursor(c),
|
|
6236
6116
|
identity: FfiConverterOptionalTypeIdentity.readFromCursor(c),
|
|
6237
6117
|
assertions: FfiConverterSequenceTypeAssertion.readFromCursor(c),
|
|
6238
|
-
components:
|
|
6118
|
+
components: FfiConverterSequenceTypeComponent.readFromCursor(c)
|
|
6239
6119
|
};
|
|
6240
6120
|
}
|
|
6241
6121
|
writeIntoCursor(value, c) {
|
|
6242
6122
|
FfiConverterOptionalString.writeIntoCursor(value.title, c);
|
|
6243
|
-
|
|
6123
|
+
FfiConverterTypeOrigin.writeIntoCursor(value.origin, c);
|
|
6244
6124
|
FfiConverterSequenceTypeAction.writeIntoCursor(value.actions, c);
|
|
6245
6125
|
FfiConverterOptionalTypeIdentity.writeIntoCursor(value.identity, c);
|
|
6246
6126
|
FfiConverterSequenceTypeAssertion.writeIntoCursor(value.assertions, c);
|
|
6247
|
-
|
|
6127
|
+
FfiConverterSequenceTypeComponent.writeIntoCursor(value.components, c);
|
|
6248
6128
|
}
|
|
6249
6129
|
allocationSize(value) {
|
|
6250
|
-
return FfiConverterOptionalString.allocationSize(value.title) +
|
|
6130
|
+
return FfiConverterOptionalString.allocationSize(value.title) + FfiConverterTypeOrigin.allocationSize(value.origin) + FfiConverterSequenceTypeAction.allocationSize(value.actions) + FfiConverterOptionalTypeIdentity.allocationSize(value.identity) + FfiConverterSequenceTypeAssertion.allocationSize(value.assertions) + FfiConverterSequenceTypeComponent.allocationSize(value.components);
|
|
6251
6131
|
}
|
|
6252
6132
|
}
|
|
6253
6133
|
return new FFIConverter();
|
|
6254
6134
|
})();
|
|
6255
6135
|
/**
|
|
6256
|
-
* One stream, from `init` to `stop
|
|
6136
|
+
* One live stream, from `init` to `stop`.
|
|
6257
6137
|
*
|
|
6258
|
-
* Carries the whole per-stream state, so it cannot be mistyped
|
|
6259
|
-
* stream's: every call after `init` goes through the handle that started
|
|
6260
|
-
* the stream ever appears in a caller's argument list again.
|
|
6261
|
-
* it refuses every call.
|
|
6138
|
+
* Carries the whole per-stream state, so it cannot be mistyped, reused after `stop`, or
|
|
6139
|
+
* confused with another stream's: every call after `init` goes through the handle that started
|
|
6140
|
+
* it, and nothing about the stream ever appears in a caller's argument list again.
|
|
6262
6141
|
*/
|
|
6263
6142
|
var StreamSession = class extends UniffiAbstractObject {
|
|
6264
6143
|
[uniffiTypeNameSymbol] = "StreamSession";
|
|
@@ -6272,18 +6151,17 @@ var StreamSession = class extends UniffiAbstractObject {
|
|
|
6272
6151
|
/**
|
|
6273
6152
|
* Sign one media (moof) segment from a [`RangeSource`]. Does not touch the signer channel;
|
|
6274
6153
|
* works through a signer outage. `rotation_due` flips when the key validity threshold
|
|
6275
|
-
* passes;
|
|
6154
|
+
* passes; re-`init` on the issuer to rotate.
|
|
6276
6155
|
*
|
|
6277
6156
|
* # Errors
|
|
6278
6157
|
*
|
|
6279
|
-
* Fails on a vault error, a segment that isn't a BMFF media segment
|
|
6280
|
-
* `FAILED_PRECONDITION` (`SESSION_ENDED`) after `stop` or a `rotate`.
|
|
6158
|
+
* Fails on a vault error, or a segment that isn't a BMFF media segment.
|
|
6281
6159
|
*/
|
|
6282
|
-
async sign(
|
|
6160
|
+
async sign(body, asyncOpts_) {
|
|
6283
6161
|
const __stack = uniffiIsDebug ? (/* @__PURE__ */ new Error()).stack : void 0;
|
|
6284
6162
|
try {
|
|
6285
6163
|
return await uniffiRustCallAsync(uniffiCaller, () => {
|
|
6286
|
-
return getter().uniffi_trylimbo_sdk_issuer_fn_method_streamsession_sign(uniffiTypeStreamSessionObjectFactory.clonePointer(this), FfiConverterTypeRangeSource.lower(
|
|
6164
|
+
return getter().uniffi_trylimbo_sdk_issuer_fn_method_streamsession_sign(uniffiTypeStreamSessionObjectFactory.clonePointer(this), FfiConverterTypeRangeSource.lower(body, getter().rustbuffer_alloc));
|
|
6287
6165
|
}, getter().ffi_trylimbo_sdk_issuer_rust_future_poll_rust_buffer, getter().ffi_trylimbo_sdk_issuer_rust_future_cancel_rust_buffer, getter().ffi_trylimbo_sdk_issuer_rust_future_complete_rust_buffer, getter().ffi_trylimbo_sdk_issuer_rust_future_free_rust_buffer, (__rb) => {
|
|
6288
6166
|
try {
|
|
6289
6167
|
return FfiConverterTypeSegmentOutcome.lift(__rb);
|
|
@@ -6297,13 +6175,11 @@ var StreamSession = class extends UniffiAbstractObject {
|
|
|
6297
6175
|
}
|
|
6298
6176
|
}
|
|
6299
6177
|
/**
|
|
6300
|
-
* End the stream: forget its session key, so nothing can sign under it again.
|
|
6301
|
-
* stopping an ended session succeeds. A failed stop can be retried.
|
|
6178
|
+
* End the stream: forget its session key, so nothing can sign under it again.
|
|
6302
6179
|
*
|
|
6303
6180
|
* # Errors
|
|
6304
6181
|
*
|
|
6305
|
-
* Fails on a vault error
|
|
6306
|
-
* `stop` or `rotate` in flight.
|
|
6182
|
+
* Fails on a vault error.
|
|
6307
6183
|
*/
|
|
6308
6184
|
async stop(asyncOpts_) {
|
|
6309
6185
|
const __stack = uniffiIsDebug ? (/* @__PURE__ */ new Error()).stack : void 0;
|
|
@@ -6402,8 +6278,40 @@ const FfiConverterTypeStreamStart = (() => {
|
|
|
6402
6278
|
return new FFIConverter();
|
|
6403
6279
|
})();
|
|
6404
6280
|
/**
|
|
6405
|
-
*
|
|
6406
|
-
|
|
6281
|
+
* Generated factory for {@link VaultPublicKey} record objects.
|
|
6282
|
+
*/
|
|
6283
|
+
const VaultPublicKey = (() => {
|
|
6284
|
+
const defaults = () => ({});
|
|
6285
|
+
const create = (() => {
|
|
6286
|
+
return uniffiCreateRecord(defaults);
|
|
6287
|
+
})();
|
|
6288
|
+
return Object.freeze({
|
|
6289
|
+
create,
|
|
6290
|
+
new: create,
|
|
6291
|
+
defaults: () => Object.freeze(defaults())
|
|
6292
|
+
});
|
|
6293
|
+
})();
|
|
6294
|
+
const FfiConverterTypeVaultPublicKey = (() => {
|
|
6295
|
+
class FFIConverter extends AbstractFfiConverterByteArray {
|
|
6296
|
+
readFromCursor(c) {
|
|
6297
|
+
return {
|
|
6298
|
+
kid: FfiConverterArrayBuffer.readFromCursor(c),
|
|
6299
|
+
publicKeySec1: FfiConverterArrayBuffer.readFromCursor(c)
|
|
6300
|
+
};
|
|
6301
|
+
}
|
|
6302
|
+
writeIntoCursor(value, c) {
|
|
6303
|
+
FfiConverterArrayBuffer.writeIntoCursor(value.kid, c);
|
|
6304
|
+
FfiConverterArrayBuffer.writeIntoCursor(value.publicKeySec1, c);
|
|
6305
|
+
}
|
|
6306
|
+
allocationSize(value) {
|
|
6307
|
+
return FfiConverterArrayBuffer.allocationSize(value.kid) + FfiConverterArrayBuffer.allocationSize(value.publicKeySec1);
|
|
6308
|
+
}
|
|
6309
|
+
}
|
|
6310
|
+
return new FFIConverter();
|
|
6311
|
+
})();
|
|
6312
|
+
/**
|
|
6313
|
+
* Whether a fragmented-MP4 segment is the init (moov) or a media (moof) segment: which
|
|
6314
|
+
* [`StreamIssuer`](stream::StreamIssuer) entrypoint (`init` vs `sign`) a segment belongs to.
|
|
6407
6315
|
*/
|
|
6408
6316
|
let SegmentKind = /* @__PURE__ */ function(SegmentKind) {
|
|
6409
6317
|
SegmentKind[SegmentKind["Init"] = 0] = "Init";
|
|
@@ -6450,9 +6358,9 @@ const uniffiCallbackInterfacePluginAuthor = {
|
|
|
6450
6358
|
uniffiTraitInterfaceCallWithError(uniffiMakeCall, uniffiHandleSuccess, uniffiHandleError, SdkError.instanceOf, FfiConverterTypeSdkError.lower.bind(FfiConverterTypeSdkError), FfiConverterString.lower.bind(FfiConverterString), getter().rustbuffer_alloc);
|
|
6451
6359
|
return uniffiResult;
|
|
6452
6360
|
},
|
|
6453
|
-
sniff: (uniffiHandle,
|
|
6361
|
+
sniff: (uniffiHandle, src, uniffiFutureCallback, uniffiCallbackData) => {
|
|
6454
6362
|
const uniffiMakeCall = async (signal) => {
|
|
6455
|
-
return await FfiConverterTypePluginAuthor.lift(uniffiHandle).sniff(FfiConverterTypeRangeSource.lift(
|
|
6363
|
+
return await FfiConverterTypePluginAuthor.lift(uniffiHandle).sniff(FfiConverterTypeRangeSource.lift(src), { signal });
|
|
6456
6364
|
};
|
|
6457
6365
|
const uniffiHandleSuccess = (returnValue) => {
|
|
6458
6366
|
uniffiFutureCallback.call(uniffiFutureCallback, uniffiCallbackData, {
|
|
@@ -6468,13 +6376,13 @@ const uniffiCallbackInterfacePluginAuthor = {
|
|
|
6468
6376
|
};
|
|
6469
6377
|
return uniffiTraitInterfaceCallAsyncWithError(uniffiMakeCall, uniffiHandleSuccess, uniffiHandleError, SdkError.instanceOf, FfiConverterTypeSdkError.lower.bind(FfiConverterTypeSdkError), FfiConverterString.lower.bind(FfiConverterString), getter().rustbuffer_alloc);
|
|
6470
6378
|
},
|
|
6471
|
-
locate: (uniffiHandle,
|
|
6379
|
+
locate: (uniffiHandle, src, uniffiFutureCallback, uniffiCallbackData) => {
|
|
6472
6380
|
const uniffiMakeCall = async (signal) => {
|
|
6473
|
-
return await FfiConverterTypePluginAuthor.lift(uniffiHandle).locate(FfiConverterTypeRangeSource.lift(
|
|
6381
|
+
return await FfiConverterTypePluginAuthor.lift(uniffiHandle).locate(FfiConverterTypeRangeSource.lift(src), { signal });
|
|
6474
6382
|
};
|
|
6475
6383
|
const uniffiHandleSuccess = (returnValue) => {
|
|
6476
6384
|
uniffiFutureCallback.call(uniffiFutureCallback, uniffiCallbackData, {
|
|
6477
|
-
return_value:
|
|
6385
|
+
return_value: FfiConverterSequenceTypeRegion.lower(returnValue, getter().rustbuffer_alloc),
|
|
6478
6386
|
call_status: uniffiCaller.createCallStatus()
|
|
6479
6387
|
});
|
|
6480
6388
|
};
|
|
@@ -6486,13 +6394,13 @@ const uniffiCallbackInterfacePluginAuthor = {
|
|
|
6486
6394
|
};
|
|
6487
6395
|
return uniffiTraitInterfaceCallAsyncWithError(uniffiMakeCall, uniffiHandleSuccess, uniffiHandleError, SdkError.instanceOf, FfiConverterTypeSdkError.lower.bind(FfiConverterTypeSdkError), FfiConverterString.lower.bind(FfiConverterString), getter().rustbuffer_alloc);
|
|
6488
6396
|
},
|
|
6489
|
-
reserve_slot: (uniffiHandle,
|
|
6397
|
+
reserve_slot: (uniffiHandle, dst, reserve, uniffiFutureCallback, uniffiCallbackData) => {
|
|
6490
6398
|
const uniffiMakeCall = async (signal) => {
|
|
6491
|
-
return await FfiConverterTypePluginAuthor.lift(uniffiHandle).reserveSlot(FfiConverterTypeRangeSink.lift(
|
|
6399
|
+
return await FfiConverterTypePluginAuthor.lift(uniffiHandle).reserveSlot(FfiConverterTypeRangeSink.lift(dst), FfiConverterUInt64.lift(reserve), { signal });
|
|
6492
6400
|
};
|
|
6493
6401
|
const uniffiHandleSuccess = (returnValue) => {
|
|
6494
6402
|
uniffiFutureCallback.call(uniffiFutureCallback, uniffiCallbackData, {
|
|
6495
|
-
return_value:
|
|
6403
|
+
return_value: FfiConverterSequenceTypeRegion.lower(returnValue, getter().rustbuffer_alloc),
|
|
6496
6404
|
call_status: uniffiCaller.createCallStatus()
|
|
6497
6405
|
});
|
|
6498
6406
|
};
|
|
@@ -6538,16 +6446,18 @@ var AssetIssuer = class extends UniffiAbstractObject {
|
|
|
6538
6446
|
}, FfiConverterString.lift.bind(FfiConverterString)));
|
|
6539
6447
|
}
|
|
6540
6448
|
/**
|
|
6541
|
-
* Sign an asset from a [`RangeSource`], returning the sidecar
|
|
6542
|
-
* `options.delivery`
|
|
6543
|
-
*
|
|
6449
|
+
* Sign an asset from a [`RangeSource`], returning the sidecar plus the registry
|
|
6450
|
+
* `manifest_id`. `options.delivery` selects where the manifest lives, its binders and,
|
|
6451
|
+
* through its output, the sink the signed asset is written through. `options.format` is
|
|
6452
|
+
* how the asset's format is known. `plugins` resolves a non-c2pa format (e.g. MXF); see the
|
|
6453
|
+
* module docs for the dispatch.
|
|
6544
6454
|
*
|
|
6545
6455
|
* # Errors
|
|
6546
6456
|
*
|
|
6547
|
-
*
|
|
6548
|
-
*
|
|
6457
|
+
* Fails on RPC failure, a hashing error, an authoring error, a protocol violation,
|
|
6458
|
+
* or when the format can't be inferred and none was given.
|
|
6549
6459
|
*/
|
|
6550
|
-
async sign(source, manifest, options, plugins
|
|
6460
|
+
async sign(source, manifest, options, plugins, asyncOpts_) {
|
|
6551
6461
|
const __stack = uniffiIsDebug ? (/* @__PURE__ */ new Error()).stack : void 0;
|
|
6552
6462
|
try {
|
|
6553
6463
|
return await uniffiRustCallAsync(uniffiCaller, () => {
|
|
@@ -6618,10 +6528,11 @@ const uniffiTypeAssetIssuerObjectFactory = (() => {
|
|
|
6618
6528
|
})();
|
|
6619
6529
|
const FfiConverterTypeAssetIssuer = new FfiConverterObject(uniffiTypeAssetIssuerObjectFactory);
|
|
6620
6530
|
/**
|
|
6621
|
-
*
|
|
6531
|
+
* Applies invisible watermarks through the deployment's marking service.
|
|
6622
6532
|
*
|
|
6623
6533
|
* Separate from [`AssetIssuer`] because marking is a content edit, not a signing step: it
|
|
6624
|
-
* happens before signing, and it returns the
|
|
6534
|
+
* changes pixels, it happens before signing, and it returns the provenance facts it created
|
|
6535
|
+
* rather than leaving anything downstream to infer them.
|
|
6625
6536
|
*/
|
|
6626
6537
|
var AssetMarker = class extends UniffiAbstractObject {
|
|
6627
6538
|
[uniffiTypeNameSymbol] = "AssetMarker";
|
|
@@ -6641,21 +6552,19 @@ var AssetMarker = class extends UniffiAbstractObject {
|
|
|
6641
6552
|
}, FfiConverterString.lift.bind(FfiConverterString)));
|
|
6642
6553
|
}
|
|
6643
6554
|
/**
|
|
6644
|
-
* Mark an
|
|
6645
|
-
*
|
|
6646
|
-
* Sign what `into` holds.
|
|
6555
|
+
* Mark an image from a [`RangeSource`] and return it with the actions the marking created,
|
|
6556
|
+
* each bound one carrying its binding.
|
|
6647
6557
|
*
|
|
6648
6558
|
* # Errors
|
|
6649
6559
|
*
|
|
6650
|
-
*
|
|
6651
|
-
*
|
|
6652
|
-
* refused or answered out of contract.
|
|
6560
|
+
* Fails when the format can't be resolved, the asset is above the upload ceiling, the HTTP
|
|
6561
|
+
* request fails, or the service response is malformed.
|
|
6653
6562
|
*/
|
|
6654
|
-
async mark(source,
|
|
6563
|
+
async mark(source, options, asyncOpts_) {
|
|
6655
6564
|
const __stack = uniffiIsDebug ? (/* @__PURE__ */ new Error()).stack : void 0;
|
|
6656
6565
|
try {
|
|
6657
6566
|
return await uniffiRustCallAsync(uniffiCaller, () => {
|
|
6658
|
-
return getter().uniffi_trylimbo_sdk_issuer_fn_method_assetmarker_mark(uniffiTypeAssetMarkerObjectFactory.clonePointer(this), FfiConverterTypeRangeSource.lower(source, getter().rustbuffer_alloc),
|
|
6567
|
+
return getter().uniffi_trylimbo_sdk_issuer_fn_method_assetmarker_mark(uniffiTypeAssetMarkerObjectFactory.clonePointer(this), FfiConverterTypeRangeSource.lower(source, getter().rustbuffer_alloc), FfiConverterTypeMarkOptions.lower(options, getter().rustbuffer_alloc));
|
|
6659
6568
|
}, getter().ffi_trylimbo_sdk_issuer_rust_future_poll_rust_buffer, getter().ffi_trylimbo_sdk_issuer_rust_future_cancel_rust_buffer, getter().ffi_trylimbo_sdk_issuer_rust_future_complete_rust_buffer, getter().ffi_trylimbo_sdk_issuer_rust_future_free_rust_buffer, (__rb) => {
|
|
6660
6569
|
try {
|
|
6661
6570
|
return FfiConverterTypeMarkOutcome.lift(__rb);
|
|
@@ -6733,6 +6642,10 @@ const FfiConverterTypeAssetMarker = new FfiConverterObject(uniffiTypeAssetMarker
|
|
|
6733
6642
|
* That is what makes [`MemorySink`]'s ceiling stop applying: there is no byte array to count in an
|
|
6734
6643
|
* `i32` and nothing resident, so a multi-GB master is signed at the disk's speed rather than the
|
|
6735
6644
|
* host thread's, and `bytes()` is not something anyone has to call.
|
|
6645
|
+
*
|
|
6646
|
+
* No lock. A positioned write to a file is one `pwrite`, which the OS already makes atomic per
|
|
6647
|
+
* call, and [`RangeWriter`] takes a shared borrow precisely so a backend like this pays nothing
|
|
6648
|
+
* for being shared.
|
|
6736
6649
|
*/
|
|
6737
6650
|
var FileSink = class extends UniffiAbstractObject {
|
|
6738
6651
|
[uniffiTypeNameSymbol] = "FileSink";
|
|
@@ -6744,8 +6657,8 @@ var FileSink = class extends UniffiAbstractObject {
|
|
|
6744
6657
|
this[destructorGuardSymbol] = uniffiTypeFileSinkObjectFactory.bless(pointer);
|
|
6745
6658
|
}
|
|
6746
6659
|
/**
|
|
6747
|
-
* Create `path`, or truncate it if it is already there. What
|
|
6748
|
-
*
|
|
6660
|
+
* Create `path`, or truncate it if it is already there. What `embed` wants: it composes a
|
|
6661
|
+
* whole asset, so the sink starts empty and grows.
|
|
6749
6662
|
*
|
|
6750
6663
|
* # Errors
|
|
6751
6664
|
*
|
|
@@ -6757,9 +6670,9 @@ var FileSink = class extends UniffiAbstractObject {
|
|
|
6757
6670
|
}, FfiConverterString.lift.bind(FfiConverterString)));
|
|
6758
6671
|
}
|
|
6759
6672
|
/**
|
|
6760
|
-
* Open an existing `path` for reading and writing, keeping what is in it. What
|
|
6761
|
-
* the asset is already there and
|
|
6762
|
-
* destroy the very thing being signed.
|
|
6673
|
+
* Open an existing `path` for reading and writing, keeping what is in it. What a fixed-slot
|
|
6674
|
+
* patch wants: the asset is already there and only its reserved range changes, so truncating
|
|
6675
|
+
* it would destroy the very thing being signed.
|
|
6763
6676
|
*
|
|
6764
6677
|
* # Errors
|
|
6765
6678
|
*
|
|
@@ -6992,8 +6905,188 @@ const uniffiTypeFileSourceObjectFactory = (() => {
|
|
|
6992
6905
|
})();
|
|
6993
6906
|
const FfiConverterTypeFileSource = new FfiConverterObject(uniffiTypeFileSourceObjectFactory);
|
|
6994
6907
|
/**
|
|
6995
|
-
*
|
|
6996
|
-
|
|
6908
|
+
* A binding you already hold, such as an out-of-band video ISCC. Reads nothing.
|
|
6909
|
+
*/
|
|
6910
|
+
var HeldBinder = class extends UniffiAbstractObject {
|
|
6911
|
+
[uniffiTypeNameSymbol] = "HeldBinder";
|
|
6912
|
+
[destructorGuardSymbol];
|
|
6913
|
+
[pointerLiteralSymbol];
|
|
6914
|
+
/**
|
|
6915
|
+
* # Errors
|
|
6916
|
+
*
|
|
6917
|
+
* A binding with an empty algorithm or value.
|
|
6918
|
+
*/
|
|
6919
|
+
constructor(binding) {
|
|
6920
|
+
super();
|
|
6921
|
+
const pointer = uniffiCaller.rustCallWithError(FfiConverterTypeSdkError.lift.bind(FfiConverterTypeSdkError), (callStatus) => {
|
|
6922
|
+
return getter().uniffi_trylimbo_sdk_issuer_fn_constructor_heldbinder_new(FfiConverterTypeSoftBinding.lower(binding, getter().rustbuffer_alloc), callStatus);
|
|
6923
|
+
}, FfiConverterString.lift.bind(FfiConverterString));
|
|
6924
|
+
this[pointerLiteralSymbol] = pointer;
|
|
6925
|
+
this[destructorGuardSymbol] = uniffiTypeHeldBinderObjectFactory.bless(pointer);
|
|
6926
|
+
}
|
|
6927
|
+
async derive(source, options, asyncOpts_) {
|
|
6928
|
+
const __stack = uniffiIsDebug ? (/* @__PURE__ */ new Error()).stack : void 0;
|
|
6929
|
+
try {
|
|
6930
|
+
return await uniffiRustCallAsync(uniffiCaller, () => {
|
|
6931
|
+
return getter().uniffi_trylimbo_sdk_issuer_fn_method_heldbinder_derive(uniffiTypeHeldBinderObjectFactory.clonePointer(this), FfiConverterTypeRangeSource.lower(source, getter().rustbuffer_alloc), FfiConverterTypeDeriveOptions.lower(options, getter().rustbuffer_alloc));
|
|
6932
|
+
}, getter().ffi_trylimbo_sdk_issuer_rust_future_poll_rust_buffer, getter().ffi_trylimbo_sdk_issuer_rust_future_cancel_rust_buffer, getter().ffi_trylimbo_sdk_issuer_rust_future_complete_rust_buffer, getter().ffi_trylimbo_sdk_issuer_rust_future_free_rust_buffer, (__rb) => {
|
|
6933
|
+
try {
|
|
6934
|
+
return FfiConverterOptionalTypeSoftBinding.lift(__rb);
|
|
6935
|
+
} finally {
|
|
6936
|
+
getter().rustbuffer_free(__rb);
|
|
6937
|
+
}
|
|
6938
|
+
}, FfiConverterString.lift.bind(FfiConverterString), asyncOpts_, FfiConverterTypeSdkError.lift.bind(FfiConverterTypeSdkError));
|
|
6939
|
+
} catch (__error) {
|
|
6940
|
+
if (uniffiIsDebug && __error instanceof Error) __error.stack = __stack;
|
|
6941
|
+
throw __error;
|
|
6942
|
+
}
|
|
6943
|
+
}
|
|
6944
|
+
uniffiDestroy() {
|
|
6945
|
+
const ptr = this[destructorGuardSymbol];
|
|
6946
|
+
if (ptr !== void 0) {
|
|
6947
|
+
const pointer = uniffiTypeHeldBinderObjectFactory.pointer(this);
|
|
6948
|
+
uniffiTypeHeldBinderObjectFactory.freePointer(pointer);
|
|
6949
|
+
uniffiTypeHeldBinderObjectFactory.unbless(ptr);
|
|
6950
|
+
delete this[destructorGuardSymbol];
|
|
6951
|
+
}
|
|
6952
|
+
}
|
|
6953
|
+
static instanceOf(obj_) {
|
|
6954
|
+
return uniffiTypeHeldBinderObjectFactory.isConcreteType(obj_);
|
|
6955
|
+
}
|
|
6956
|
+
};
|
|
6957
|
+
const uniffiTypeHeldBinderObjectFactory = (() => {
|
|
6958
|
+
const registry = typeof FinalizationRegistry !== "undefined" ? new FinalizationRegistry((heldValue) => {
|
|
6959
|
+
uniffiTypeHeldBinderObjectFactory.freePointer(heldValue);
|
|
6960
|
+
}) : null;
|
|
6961
|
+
return {
|
|
6962
|
+
create(pointer) {
|
|
6963
|
+
const instance = Object.create(HeldBinder.prototype);
|
|
6964
|
+
instance[pointerLiteralSymbol] = pointer;
|
|
6965
|
+
instance[destructorGuardSymbol] = this.bless(pointer);
|
|
6966
|
+
instance[uniffiTypeNameSymbol] = "HeldBinder";
|
|
6967
|
+
return instance;
|
|
6968
|
+
},
|
|
6969
|
+
bless(p) {
|
|
6970
|
+
const ptr = {
|
|
6971
|
+
p,
|
|
6972
|
+
markDestroyed: () => void 0
|
|
6973
|
+
};
|
|
6974
|
+
if (registry) registry.register(ptr, p, ptr);
|
|
6975
|
+
return ptr;
|
|
6976
|
+
},
|
|
6977
|
+
unbless(ptr_) {
|
|
6978
|
+
if (registry) registry.unregister(ptr_);
|
|
6979
|
+
},
|
|
6980
|
+
pointer(obj_) {
|
|
6981
|
+
if (obj_[destructorGuardSymbol] === void 0) throw new UniffiInternalError.UnexpectedNullPointer();
|
|
6982
|
+
return obj_[pointerLiteralSymbol];
|
|
6983
|
+
},
|
|
6984
|
+
clonePointer(obj_) {
|
|
6985
|
+
const pointer = this.pointer(obj_);
|
|
6986
|
+
return uniffiCaller.rustCall((callStatus) => getter().uniffi_trylimbo_sdk_issuer_fn_clone_heldbinder(pointer, callStatus), FfiConverterString.lift);
|
|
6987
|
+
},
|
|
6988
|
+
freePointer(pointer) {
|
|
6989
|
+
uniffiCaller.rustCall((callStatus) => getter().uniffi_trylimbo_sdk_issuer_fn_free_heldbinder(pointer, callStatus), FfiConverterString.lift);
|
|
6990
|
+
},
|
|
6991
|
+
isConcreteType(obj_) {
|
|
6992
|
+
return obj_[destructorGuardSymbol] && obj_[uniffiTypeNameSymbol] === "HeldBinder";
|
|
6993
|
+
}
|
|
6994
|
+
};
|
|
6995
|
+
})();
|
|
6996
|
+
const FfiConverterTypeHeldBinder = new FfiConverterObject(uniffiTypeHeldBinderObjectFactory);
|
|
6997
|
+
/**
|
|
6998
|
+
* Local ISCC Image-Code for supported image formats.
|
|
6999
|
+
*/
|
|
7000
|
+
var IsccBinder = class extends UniffiAbstractObject {
|
|
7001
|
+
[uniffiTypeNameSymbol] = "IsccBinder";
|
|
7002
|
+
[destructorGuardSymbol];
|
|
7003
|
+
[pointerLiteralSymbol];
|
|
7004
|
+
constructor() {
|
|
7005
|
+
super();
|
|
7006
|
+
const pointer = uniffiCaller.rustCall((callStatus) => {
|
|
7007
|
+
return getter().uniffi_trylimbo_sdk_issuer_fn_constructor_isccbinder_new(callStatus);
|
|
7008
|
+
}, FfiConverterString.lift.bind(FfiConverterString));
|
|
7009
|
+
this[pointerLiteralSymbol] = pointer;
|
|
7010
|
+
this[destructorGuardSymbol] = uniffiTypeIsccBinderObjectFactory.bless(pointer);
|
|
7011
|
+
}
|
|
7012
|
+
async derive(source, options, asyncOpts_) {
|
|
7013
|
+
const __stack = uniffiIsDebug ? (/* @__PURE__ */ new Error()).stack : void 0;
|
|
7014
|
+
try {
|
|
7015
|
+
return await uniffiRustCallAsync(uniffiCaller, () => {
|
|
7016
|
+
return getter().uniffi_trylimbo_sdk_issuer_fn_method_isccbinder_derive(uniffiTypeIsccBinderObjectFactory.clonePointer(this), FfiConverterTypeRangeSource.lower(source, getter().rustbuffer_alloc), FfiConverterTypeDeriveOptions.lower(options, getter().rustbuffer_alloc));
|
|
7017
|
+
}, getter().ffi_trylimbo_sdk_issuer_rust_future_poll_rust_buffer, getter().ffi_trylimbo_sdk_issuer_rust_future_cancel_rust_buffer, getter().ffi_trylimbo_sdk_issuer_rust_future_complete_rust_buffer, getter().ffi_trylimbo_sdk_issuer_rust_future_free_rust_buffer, (__rb) => {
|
|
7018
|
+
try {
|
|
7019
|
+
return FfiConverterOptionalTypeSoftBinding.lift(__rb);
|
|
7020
|
+
} finally {
|
|
7021
|
+
getter().rustbuffer_free(__rb);
|
|
7022
|
+
}
|
|
7023
|
+
}, FfiConverterString.lift.bind(FfiConverterString), asyncOpts_, FfiConverterTypeSdkError.lift.bind(FfiConverterTypeSdkError));
|
|
7024
|
+
} catch (__error) {
|
|
7025
|
+
if (uniffiIsDebug && __error instanceof Error) __error.stack = __stack;
|
|
7026
|
+
throw __error;
|
|
7027
|
+
}
|
|
7028
|
+
}
|
|
7029
|
+
uniffiDestroy() {
|
|
7030
|
+
const ptr = this[destructorGuardSymbol];
|
|
7031
|
+
if (ptr !== void 0) {
|
|
7032
|
+
const pointer = uniffiTypeIsccBinderObjectFactory.pointer(this);
|
|
7033
|
+
uniffiTypeIsccBinderObjectFactory.freePointer(pointer);
|
|
7034
|
+
uniffiTypeIsccBinderObjectFactory.unbless(ptr);
|
|
7035
|
+
delete this[destructorGuardSymbol];
|
|
7036
|
+
}
|
|
7037
|
+
}
|
|
7038
|
+
static instanceOf(obj_) {
|
|
7039
|
+
return uniffiTypeIsccBinderObjectFactory.isConcreteType(obj_);
|
|
7040
|
+
}
|
|
7041
|
+
};
|
|
7042
|
+
const uniffiTypeIsccBinderObjectFactory = (() => {
|
|
7043
|
+
const registry = typeof FinalizationRegistry !== "undefined" ? new FinalizationRegistry((heldValue) => {
|
|
7044
|
+
uniffiTypeIsccBinderObjectFactory.freePointer(heldValue);
|
|
7045
|
+
}) : null;
|
|
7046
|
+
return {
|
|
7047
|
+
create(pointer) {
|
|
7048
|
+
const instance = Object.create(IsccBinder.prototype);
|
|
7049
|
+
instance[pointerLiteralSymbol] = pointer;
|
|
7050
|
+
instance[destructorGuardSymbol] = this.bless(pointer);
|
|
7051
|
+
instance[uniffiTypeNameSymbol] = "IsccBinder";
|
|
7052
|
+
return instance;
|
|
7053
|
+
},
|
|
7054
|
+
bless(p) {
|
|
7055
|
+
const ptr = {
|
|
7056
|
+
p,
|
|
7057
|
+
markDestroyed: () => void 0
|
|
7058
|
+
};
|
|
7059
|
+
if (registry) registry.register(ptr, p, ptr);
|
|
7060
|
+
return ptr;
|
|
7061
|
+
},
|
|
7062
|
+
unbless(ptr_) {
|
|
7063
|
+
if (registry) registry.unregister(ptr_);
|
|
7064
|
+
},
|
|
7065
|
+
pointer(obj_) {
|
|
7066
|
+
if (obj_[destructorGuardSymbol] === void 0) throw new UniffiInternalError.UnexpectedNullPointer();
|
|
7067
|
+
return obj_[pointerLiteralSymbol];
|
|
7068
|
+
},
|
|
7069
|
+
clonePointer(obj_) {
|
|
7070
|
+
const pointer = this.pointer(obj_);
|
|
7071
|
+
return uniffiCaller.rustCall((callStatus) => getter().uniffi_trylimbo_sdk_issuer_fn_clone_isccbinder(pointer, callStatus), FfiConverterString.lift);
|
|
7072
|
+
},
|
|
7073
|
+
freePointer(pointer) {
|
|
7074
|
+
uniffiCaller.rustCall((callStatus) => getter().uniffi_trylimbo_sdk_issuer_fn_free_isccbinder(pointer, callStatus), FfiConverterString.lift);
|
|
7075
|
+
},
|
|
7076
|
+
isConcreteType(obj_) {
|
|
7077
|
+
return obj_[destructorGuardSymbol] && obj_[uniffiTypeNameSymbol] === "IsccBinder";
|
|
7078
|
+
}
|
|
7079
|
+
};
|
|
7080
|
+
})();
|
|
7081
|
+
const FfiConverterTypeIsccBinder = new FfiConverterObject(uniffiTypeIsccBinderObjectFactory);
|
|
7082
|
+
/**
|
|
7083
|
+
* An in-memory [`RangeSink`], for a caller that wants `embed`'s composed result back
|
|
7084
|
+
* without writing a custom sink. A **native** implementation of a `with_foreign`
|
|
7085
|
+
* interface (`#[uniffi::export]` on the trait impl, not the foreign callback path), so
|
|
7086
|
+
* a Python caller writes no subclass: `sink = MemorySink(data)`, pass it to `embed`,
|
|
7087
|
+
* then read `sink.bytes()` back. `&self`-only methods need interior mutability, so the
|
|
7088
|
+
* buffer is `Mutex`-guarded (contention is a non-issue: the SDK calls it from one task
|
|
7089
|
+
* at a time per sink).
|
|
6997
7090
|
*
|
|
6998
7091
|
* # Size ceiling
|
|
6999
7092
|
*
|
|
@@ -7005,8 +7098,9 @@ const FfiConverterTypeFileSource = new FfiConverterObject(uniffiTypeFileSourceOb
|
|
|
7005
7098
|
* [`RangeSink`] over a file (or any store that seeks) for anything approaching that: the SDK
|
|
7006
7099
|
* writes ranges straight through it and never holds the asset.
|
|
7007
7100
|
*
|
|
7008
|
-
* Construction and `bytes()` each
|
|
7009
|
-
*
|
|
7101
|
+
* Construction and `bytes()` each copy the whole asset, on the calling thread: together with a
|
|
7102
|
+
* `MemorySource` over the same asset that is about 12ms for 10 MB and 1.2s for 500 MB. A ranged
|
|
7103
|
+
* sink pays none of it.
|
|
7010
7104
|
*/
|
|
7011
7105
|
var MemorySink = class extends UniffiAbstractObject {
|
|
7012
7106
|
[uniffiTypeNameSymbol] = "MemorySink";
|
|
@@ -7147,8 +7241,11 @@ const uniffiTypeMemorySinkObjectFactory = (() => {
|
|
|
7147
7241
|
})();
|
|
7148
7242
|
const FfiConverterTypeMemorySink = new FfiConverterObject(uniffiTypeMemorySinkObjectFactory);
|
|
7149
7243
|
/**
|
|
7150
|
-
* An in-memory [`RangeSource`] for a caller that already holds the whole asset as
|
|
7151
|
-
*
|
|
7244
|
+
* An in-memory [`RangeSource`], for a caller that already holds the whole asset as
|
|
7245
|
+
* bytes and doesn't want to write a custom source. A **native** implementation of a
|
|
7246
|
+
* `with_foreign` interface (`#[uniffi::export]` on the trait impl, not the foreign
|
|
7247
|
+
* callback path), so the generated binding is a plain constructible object and a Python
|
|
7248
|
+
* caller writes no subclass at all: `MemorySource(data)`.
|
|
7152
7249
|
*
|
|
7153
7250
|
* # Size ceiling
|
|
7154
7251
|
*
|
|
@@ -7158,10 +7255,9 @@ const FfiConverterTypeMemorySink = new FfiConverterObject(uniffiTypeMemorySinkOb
|
|
|
7158
7255
|
* [`RangeSource`] over a file handle for anything approaching that: the SDK only ever asks for
|
|
7159
7256
|
* bounded ranges, so nothing else has to hold the asset.
|
|
7160
7257
|
*
|
|
7161
|
-
* Construction
|
|
7162
|
-
*
|
|
7163
|
-
*
|
|
7164
|
-
* [`FileSource`] pays it.
|
|
7258
|
+
* Construction copies the whole asset across the boundary, on the calling thread: about 5ms for
|
|
7259
|
+
* 10 MB, 315ms for 500 MB. That is the one part of a sign or verify the SDK cannot move off your
|
|
7260
|
+
* thread, and neither a ranged source nor [`FileSource`] pays it.
|
|
7165
7261
|
*/
|
|
7166
7262
|
var MemorySource = class extends UniffiAbstractObject {
|
|
7167
7263
|
[uniffiTypeNameSymbol] = "MemorySource";
|
|
@@ -7283,7 +7379,7 @@ var SignerClient = class extends UniffiAbstractObject {
|
|
|
7283
7379
|
* `options` is malformed. The channel connects lazily, so an unreachable Signer
|
|
7284
7380
|
* surfaces on the first sign RPC instead.
|
|
7285
7381
|
*/
|
|
7286
|
-
static async connect(endpoint, options
|
|
7382
|
+
static async connect(endpoint, options, asyncOpts_) {
|
|
7287
7383
|
const __stack = uniffiIsDebug ? (/* @__PURE__ */ new Error()).stack : void 0;
|
|
7288
7384
|
try {
|
|
7289
7385
|
return await uniffiRustCallAsync(uniffiCaller, () => {
|
|
@@ -7348,7 +7444,7 @@ const uniffiTypeSignerClientObjectFactory = (() => {
|
|
|
7348
7444
|
})();
|
|
7349
7445
|
const FfiConverterTypeSignerClient = new FfiConverterObject(uniffiTypeSignerClientObjectFactory);
|
|
7350
7446
|
/**
|
|
7351
|
-
* A stream signer bound to a [`SignerClient`](super::client::SignerClient) and a
|
|
7447
|
+
* A live-stream signer bound to a [`SignerClient`](super::client::SignerClient) and a
|
|
7352
7448
|
* [`SigningVault`]. Construct once with [`create`](Self::create), then `init` a session and
|
|
7353
7449
|
* sign every segment through the [`StreamSession`] it returns.
|
|
7354
7450
|
*/
|
|
@@ -7370,21 +7466,22 @@ var StreamIssuer = class extends UniffiAbstractObject {
|
|
|
7370
7466
|
}, FfiConverterString.lift.bind(FfiConverterString)));
|
|
7371
7467
|
}
|
|
7372
7468
|
/**
|
|
7373
|
-
* Open the stream `
|
|
7374
|
-
* init (moov) segment
|
|
7375
|
-
* to sign through.
|
|
7469
|
+
* Open the stream at `stream_id`: mint its first session key under
|
|
7470
|
+
* `options.rotation_policy`, sign the init (moov) segment under `options.delivery`, and
|
|
7471
|
+
* hand back a [`StreamSession`] to sign through.
|
|
7376
7472
|
*
|
|
7377
7473
|
* On `rotation_due`, call [`StreamIssuer::rotate`], not this.
|
|
7378
7474
|
*
|
|
7379
7475
|
* # Errors
|
|
7380
7476
|
*
|
|
7381
|
-
* Fails on signer RPC failure, a vault error, or
|
|
7477
|
+
* Fails on signer RPC failure, a vault error, or an `init_body` that isn't a BMFF init
|
|
7478
|
+
* segment.
|
|
7382
7479
|
*/
|
|
7383
|
-
async init(
|
|
7480
|
+
async init(streamId, initBody, manifest, options, asyncOpts_) {
|
|
7384
7481
|
const __stack = uniffiIsDebug ? (/* @__PURE__ */ new Error()).stack : void 0;
|
|
7385
7482
|
try {
|
|
7386
7483
|
return await uniffiRustCallAsync(uniffiCaller, () => {
|
|
7387
|
-
return getter().uniffi_trylimbo_sdk_issuer_fn_method_streamissuer_init(uniffiTypeStreamIssuerObjectFactory.clonePointer(this), FfiConverterString.lower(
|
|
7484
|
+
return getter().uniffi_trylimbo_sdk_issuer_fn_method_streamissuer_init(uniffiTypeStreamIssuerObjectFactory.clonePointer(this), FfiConverterString.lower(streamId, getter().rustbuffer_alloc), FfiConverterTypeRangeSource.lower(initBody, getter().rustbuffer_alloc), FfiConverterTypeStreamManifestSpec.lower(manifest, getter().rustbuffer_alloc), FfiConverterTypeInitOptions.lower(options, getter().rustbuffer_alloc));
|
|
7388
7485
|
}, getter().ffi_trylimbo_sdk_issuer_rust_future_poll_rust_buffer, getter().ffi_trylimbo_sdk_issuer_rust_future_cancel_rust_buffer, getter().ffi_trylimbo_sdk_issuer_rust_future_complete_rust_buffer, getter().ffi_trylimbo_sdk_issuer_rust_future_free_rust_buffer, (__rb) => {
|
|
7389
7486
|
try {
|
|
7390
7487
|
return FfiConverterTypeStreamStart.lift(__rb);
|
|
@@ -7399,8 +7496,7 @@ var StreamIssuer = class extends UniffiAbstractObject {
|
|
|
7399
7496
|
}
|
|
7400
7497
|
/**
|
|
7401
7498
|
* Succeed `session` on the stream it already names, signing a fresh init (moov) segment
|
|
7402
|
-
* under a new key and forgetting the outgoing one.
|
|
7403
|
-
* sign; until then it keeps signing, so a failed rotation can be retried.
|
|
7499
|
+
* under a new key and forgetting the outgoing one.
|
|
7404
7500
|
*
|
|
7405
7501
|
* The stream id comes from `session`, so a rotation cannot be pointed at the wrong stream,
|
|
7406
7502
|
* and the retired key cannot be left behind: it would still sign for the rest of its
|
|
@@ -7408,14 +7504,13 @@ var StreamIssuer = class extends UniffiAbstractObject {
|
|
|
7408
7504
|
*
|
|
7409
7505
|
* # Errors
|
|
7410
7506
|
*
|
|
7411
|
-
* As [`StreamIssuer::init`]
|
|
7412
|
-
* already stopped or rotated, or with a `stop` or `rotate` in flight.
|
|
7507
|
+
* As [`StreamIssuer::init`].
|
|
7413
7508
|
*/
|
|
7414
|
-
async rotate(session,
|
|
7509
|
+
async rotate(session, initBody, manifest, options, asyncOpts_) {
|
|
7415
7510
|
const __stack = uniffiIsDebug ? (/* @__PURE__ */ new Error()).stack : void 0;
|
|
7416
7511
|
try {
|
|
7417
7512
|
return await uniffiRustCallAsync(uniffiCaller, () => {
|
|
7418
|
-
return getter().uniffi_trylimbo_sdk_issuer_fn_method_streamissuer_rotate(uniffiTypeStreamIssuerObjectFactory.clonePointer(this), FfiConverterTypeStreamSession.lower(session, getter().rustbuffer_alloc), FfiConverterTypeRangeSource.lower(
|
|
7513
|
+
return getter().uniffi_trylimbo_sdk_issuer_fn_method_streamissuer_rotate(uniffiTypeStreamIssuerObjectFactory.clonePointer(this), FfiConverterTypeStreamSession.lower(session, getter().rustbuffer_alloc), FfiConverterTypeRangeSource.lower(initBody, getter().rustbuffer_alloc), FfiConverterTypeStreamManifestSpec.lower(manifest, getter().rustbuffer_alloc), FfiConverterTypeInitOptions.lower(options, getter().rustbuffer_alloc));
|
|
7419
7514
|
}, getter().ffi_trylimbo_sdk_issuer_rust_future_poll_rust_buffer, getter().ffi_trylimbo_sdk_issuer_rust_future_cancel_rust_buffer, getter().ffi_trylimbo_sdk_issuer_rust_future_complete_rust_buffer, getter().ffi_trylimbo_sdk_issuer_rust_future_free_rust_buffer, (__rb) => {
|
|
7420
7515
|
try {
|
|
7421
7516
|
return FfiConverterTypeStreamStart.lift(__rb);
|
|
@@ -7483,13 +7578,13 @@ const uniffiTypeStreamIssuerObjectFactory = (() => {
|
|
|
7483
7578
|
const FfiConverterTypeStreamIssuer = new FfiConverterObject(uniffiTypeStreamIssuerObjectFactory);
|
|
7484
7579
|
const uniffiCallbackInterfaceSigningVault = {
|
|
7485
7580
|
vtable: {
|
|
7486
|
-
mint: (uniffiHandle,
|
|
7581
|
+
mint: (uniffiHandle, validityPeriodSecs, uniffiFutureCallback, uniffiCallbackData) => {
|
|
7487
7582
|
const uniffiMakeCall = async (signal) => {
|
|
7488
|
-
return await FfiConverterTypeSigningVault.lift(uniffiHandle).mint(
|
|
7583
|
+
return await FfiConverterTypeSigningVault.lift(uniffiHandle).mint(FfiConverterUInt64.lift(validityPeriodSecs), { signal });
|
|
7489
7584
|
};
|
|
7490
7585
|
const uniffiHandleSuccess = (returnValue) => {
|
|
7491
7586
|
uniffiFutureCallback.call(uniffiFutureCallback, uniffiCallbackData, {
|
|
7492
|
-
return_value:
|
|
7587
|
+
return_value: FfiConverterTypeVaultPublicKey.lower(returnValue, getter().rustbuffer_alloc),
|
|
7493
7588
|
call_status: uniffiCaller.createCallStatus()
|
|
7494
7589
|
});
|
|
7495
7590
|
};
|
|
@@ -7543,25 +7638,23 @@ const uniffiCallbackInterfaceSigningVault = {
|
|
|
7543
7638
|
}
|
|
7544
7639
|
};
|
|
7545
7640
|
const FfiConverterTypeSigningVault = new FfiConverterCallback();
|
|
7546
|
-
const
|
|
7547
|
-
const FfiConverterOptionalTypeSoftwareAgent = new FfiConverterOptional(FfiConverterTypeSoftwareAgent);
|
|
7641
|
+
const FfiConverterOptionalTypeTimestamp = new FfiConverterOptional(FfiConverterTypeTimestamp);
|
|
7548
7642
|
const FfiConverterOptionalString = new FfiConverterOptional(FfiConverterString);
|
|
7549
7643
|
const FfiConverterOptionalTypeUrl = new FfiConverterOptional(FfiConverterTypeUrl);
|
|
7644
|
+
const FfiConverterOptionalTypeActionDetail = new FfiConverterOptional(FfiConverterTypeActionDetail);
|
|
7550
7645
|
const FfiConverterMapStringString = new FfiConverterMap(FfiConverterString, FfiConverterString);
|
|
7551
7646
|
const FfiConverterSequenceTypeFieldViolation = new FfiConverterArray(FfiConverterTypeFieldViolation);
|
|
7552
|
-
const FfiConverterSequenceString = new FfiConverterArray(FfiConverterString);
|
|
7553
7647
|
const FfiConverterOptionalTypeThumbnail = new FfiConverterOptional(FfiConverterTypeThumbnail);
|
|
7554
|
-
const
|
|
7555
|
-
const FfiConverterOptionalTypeTimespan = new FfiConverterOptional(FfiConverterTypeTimespan);
|
|
7556
|
-
const FfiConverterSequenceTypeBlock = new FfiConverterArray(FfiConverterTypeBlock);
|
|
7648
|
+
const FfiConverterSequenceString = new FfiConverterArray(FfiConverterString);
|
|
7557
7649
|
const FfiConverterSequenceTypeAction = new FfiConverterArray(FfiConverterTypeAction);
|
|
7558
7650
|
const FfiConverterSequenceTypeJsonValue = new FfiConverterArray(FfiConverterTypeJsonValue);
|
|
7559
7651
|
const FfiConverterOptionalTypeIdentity = new FfiConverterOptional(FfiConverterTypeIdentity);
|
|
7560
7652
|
const FfiConverterSequenceTypeAssertion = new FfiConverterArray(FfiConverterTypeAssertion);
|
|
7561
|
-
const
|
|
7562
|
-
const
|
|
7563
|
-
const
|
|
7564
|
-
const
|
|
7653
|
+
const FfiConverterSequenceTypeComponent = new FfiConverterArray(FfiConverterTypeComponent);
|
|
7654
|
+
const FfiConverterOptionalMapStringString = new FfiConverterOptional(FfiConverterMapStringString);
|
|
7655
|
+
const FfiConverterOptionalTypeSoftBinding = new FfiConverterOptional(FfiConverterTypeSoftBinding);
|
|
7656
|
+
const FfiConverterSequenceTypeBinder = new FfiConverterArray(FfiConverterTypeBinder);
|
|
7657
|
+
const FfiConverterSequenceTypeRegion = new FfiConverterArray(FfiConverterTypeRegion);
|
|
7565
7658
|
const FfiConverterSequenceTypePluginAuthor = new FfiConverterArray(FfiConverterTypePluginAuthor);
|
|
7566
7659
|
/**
|
|
7567
7660
|
* This should be called before anything else.
|
|
@@ -7577,17 +7670,15 @@ function uniffiEnsureInitialized() {
|
|
|
7577
7670
|
const bindingsContractVersion = 30;
|
|
7578
7671
|
const scaffoldingContractVersion = getter().ffi_trylimbo_sdk_issuer_uniffi_contract_version();
|
|
7579
7672
|
if (bindingsContractVersion !== scaffoldingContractVersion) throw new UniffiInternalError.ContractVersionMismatch(scaffoldingContractVersion, bindingsContractVersion);
|
|
7580
|
-
if (getter().uniffi_trylimbo_sdk_issuer_checksum_func_classify_segment() !==
|
|
7581
|
-
if (getter().
|
|
7582
|
-
if (getter().uniffi_trylimbo_sdk_issuer_checksum_func_embed() !== 9865) throw new UniffiInternalError.ApiChecksumMismatch("uniffi_trylimbo_sdk_issuer_checksum_func_embed");
|
|
7673
|
+
if (getter().uniffi_trylimbo_sdk_issuer_checksum_func_classify_segment() !== 34969) throw new UniffiInternalError.ApiChecksumMismatch("uniffi_trylimbo_sdk_issuer_checksum_func_classify_segment");
|
|
7674
|
+
if (getter().uniffi_trylimbo_sdk_issuer_checksum_func_embed() !== 51357) throw new UniffiInternalError.ApiChecksumMismatch("uniffi_trylimbo_sdk_issuer_checksum_func_embed");
|
|
7583
7675
|
if (getter().uniffi_trylimbo_sdk_issuer_checksum_constructor_assetissuer_create() !== 16073) throw new UniffiInternalError.ApiChecksumMismatch("uniffi_trylimbo_sdk_issuer_checksum_constructor_assetissuer_create");
|
|
7584
|
-
if (getter().uniffi_trylimbo_sdk_issuer_checksum_method_assetissuer_sign() !==
|
|
7676
|
+
if (getter().uniffi_trylimbo_sdk_issuer_checksum_method_assetissuer_sign() !== 7792) throw new UniffiInternalError.ApiChecksumMismatch("uniffi_trylimbo_sdk_issuer_checksum_method_assetissuer_sign");
|
|
7585
7677
|
if (getter().uniffi_trylimbo_sdk_issuer_checksum_constructor_assetmarker_create() !== 41968) throw new UniffiInternalError.ApiChecksumMismatch("uniffi_trylimbo_sdk_issuer_checksum_constructor_assetmarker_create");
|
|
7586
|
-
if (getter().uniffi_trylimbo_sdk_issuer_checksum_method_assetmarker_mark() !==
|
|
7587
|
-
if (getter().
|
|
7588
|
-
if (getter().
|
|
7589
|
-
if (getter().
|
|
7590
|
-
if (getter().uniffi_trylimbo_sdk_issuer_checksum_constructor_filesink_open() !== 5590) throw new UniffiInternalError.ApiChecksumMismatch("uniffi_trylimbo_sdk_issuer_checksum_constructor_filesink_open");
|
|
7678
|
+
if (getter().uniffi_trylimbo_sdk_issuer_checksum_method_assetmarker_mark() !== 20563) throw new UniffiInternalError.ApiChecksumMismatch("uniffi_trylimbo_sdk_issuer_checksum_method_assetmarker_mark");
|
|
7679
|
+
if (getter().uniffi_trylimbo_sdk_issuer_checksum_method_binder_derive() !== 34053) throw new UniffiInternalError.ApiChecksumMismatch("uniffi_trylimbo_sdk_issuer_checksum_method_binder_derive");
|
|
7680
|
+
if (getter().uniffi_trylimbo_sdk_issuer_checksum_constructor_filesink_create() !== 64376) throw new UniffiInternalError.ApiChecksumMismatch("uniffi_trylimbo_sdk_issuer_checksum_constructor_filesink_create");
|
|
7681
|
+
if (getter().uniffi_trylimbo_sdk_issuer_checksum_constructor_filesink_open() !== 23957) throw new UniffiInternalError.ApiChecksumMismatch("uniffi_trylimbo_sdk_issuer_checksum_constructor_filesink_open");
|
|
7591
7682
|
if (getter().uniffi_trylimbo_sdk_issuer_checksum_method_filesink_length() !== 7317) throw new UniffiInternalError.ApiChecksumMismatch("uniffi_trylimbo_sdk_issuer_checksum_method_filesink_length");
|
|
7592
7683
|
if (getter().uniffi_trylimbo_sdk_issuer_checksum_method_filesink_read_at() !== 17691) throw new UniffiInternalError.ApiChecksumMismatch("uniffi_trylimbo_sdk_issuer_checksum_method_filesink_read_at");
|
|
7593
7684
|
if (getter().uniffi_trylimbo_sdk_issuer_checksum_method_filesink_set_length() !== 11187) throw new UniffiInternalError.ApiChecksumMismatch("uniffi_trylimbo_sdk_issuer_checksum_method_filesink_set_length");
|
|
@@ -7595,6 +7686,10 @@ function uniffiEnsureInitialized() {
|
|
|
7595
7686
|
if (getter().uniffi_trylimbo_sdk_issuer_checksum_constructor_filesource_open() !== 55871) throw new UniffiInternalError.ApiChecksumMismatch("uniffi_trylimbo_sdk_issuer_checksum_constructor_filesource_open");
|
|
7596
7687
|
if (getter().uniffi_trylimbo_sdk_issuer_checksum_method_filesource_length() !== 21779) throw new UniffiInternalError.ApiChecksumMismatch("uniffi_trylimbo_sdk_issuer_checksum_method_filesource_length");
|
|
7597
7688
|
if (getter().uniffi_trylimbo_sdk_issuer_checksum_method_filesource_read_at() !== 16361) throw new UniffiInternalError.ApiChecksumMismatch("uniffi_trylimbo_sdk_issuer_checksum_method_filesource_read_at");
|
|
7689
|
+
if (getter().uniffi_trylimbo_sdk_issuer_checksum_constructor_heldbinder_new() !== 3337) throw new UniffiInternalError.ApiChecksumMismatch("uniffi_trylimbo_sdk_issuer_checksum_constructor_heldbinder_new");
|
|
7690
|
+
if (getter().uniffi_trylimbo_sdk_issuer_checksum_method_heldbinder_derive() !== 53022) throw new UniffiInternalError.ApiChecksumMismatch("uniffi_trylimbo_sdk_issuer_checksum_method_heldbinder_derive");
|
|
7691
|
+
if (getter().uniffi_trylimbo_sdk_issuer_checksum_constructor_isccbinder_new() !== 37585) throw new UniffiInternalError.ApiChecksumMismatch("uniffi_trylimbo_sdk_issuer_checksum_constructor_isccbinder_new");
|
|
7692
|
+
if (getter().uniffi_trylimbo_sdk_issuer_checksum_method_isccbinder_derive() !== 14860) throw new UniffiInternalError.ApiChecksumMismatch("uniffi_trylimbo_sdk_issuer_checksum_method_isccbinder_derive");
|
|
7598
7693
|
if (getter().uniffi_trylimbo_sdk_issuer_checksum_constructor_memorysink_new() !== 24274) throw new UniffiInternalError.ApiChecksumMismatch("uniffi_trylimbo_sdk_issuer_checksum_constructor_memorysink_new");
|
|
7599
7694
|
if (getter().uniffi_trylimbo_sdk_issuer_checksum_method_memorysink_bytes() !== 17480) throw new UniffiInternalError.ApiChecksumMismatch("uniffi_trylimbo_sdk_issuer_checksum_method_memorysink_bytes");
|
|
7600
7695
|
if (getter().uniffi_trylimbo_sdk_issuer_checksum_method_memorysink_length() !== 47782) throw new UniffiInternalError.ApiChecksumMismatch("uniffi_trylimbo_sdk_issuer_checksum_method_memorysink_length");
|
|
@@ -7610,14 +7705,14 @@ function uniffiEnsureInitialized() {
|
|
|
7610
7705
|
if (getter().uniffi_trylimbo_sdk_issuer_checksum_method_rangesink_set_length() !== 29967) throw new UniffiInternalError.ApiChecksumMismatch("uniffi_trylimbo_sdk_issuer_checksum_method_rangesink_set_length");
|
|
7611
7706
|
if (getter().uniffi_trylimbo_sdk_issuer_checksum_method_rangesource_length() !== 47043) throw new UniffiInternalError.ApiChecksumMismatch("uniffi_trylimbo_sdk_issuer_checksum_method_rangesource_length");
|
|
7612
7707
|
if (getter().uniffi_trylimbo_sdk_issuer_checksum_method_rangesource_read_at() !== 37877) throw new UniffiInternalError.ApiChecksumMismatch("uniffi_trylimbo_sdk_issuer_checksum_method_rangesource_read_at");
|
|
7613
|
-
if (getter().uniffi_trylimbo_sdk_issuer_checksum_constructor_signerclient_connect() !==
|
|
7708
|
+
if (getter().uniffi_trylimbo_sdk_issuer_checksum_constructor_signerclient_connect() !== 46081) throw new UniffiInternalError.ApiChecksumMismatch("uniffi_trylimbo_sdk_issuer_checksum_constructor_signerclient_connect");
|
|
7614
7709
|
if (getter().uniffi_trylimbo_sdk_issuer_checksum_constructor_streamissuer_create() !== 59358) throw new UniffiInternalError.ApiChecksumMismatch("uniffi_trylimbo_sdk_issuer_checksum_constructor_streamissuer_create");
|
|
7615
|
-
if (getter().uniffi_trylimbo_sdk_issuer_checksum_method_streamissuer_init() !==
|
|
7616
|
-
if (getter().uniffi_trylimbo_sdk_issuer_checksum_method_streamissuer_rotate() !==
|
|
7617
|
-
if (getter().uniffi_trylimbo_sdk_issuer_checksum_method_streamsession_sign() !==
|
|
7618
|
-
if (getter().uniffi_trylimbo_sdk_issuer_checksum_method_streamsession_stop() !==
|
|
7710
|
+
if (getter().uniffi_trylimbo_sdk_issuer_checksum_method_streamissuer_init() !== 26602) throw new UniffiInternalError.ApiChecksumMismatch("uniffi_trylimbo_sdk_issuer_checksum_method_streamissuer_init");
|
|
7711
|
+
if (getter().uniffi_trylimbo_sdk_issuer_checksum_method_streamissuer_rotate() !== 23153) throw new UniffiInternalError.ApiChecksumMismatch("uniffi_trylimbo_sdk_issuer_checksum_method_streamissuer_rotate");
|
|
7712
|
+
if (getter().uniffi_trylimbo_sdk_issuer_checksum_method_streamsession_sign() !== 52745) throw new UniffiInternalError.ApiChecksumMismatch("uniffi_trylimbo_sdk_issuer_checksum_method_streamsession_sign");
|
|
7713
|
+
if (getter().uniffi_trylimbo_sdk_issuer_checksum_method_streamsession_stop() !== 47039) throw new UniffiInternalError.ApiChecksumMismatch("uniffi_trylimbo_sdk_issuer_checksum_method_streamsession_stop");
|
|
7619
7714
|
uniffiCallbackInterfaceRangeSource.register();
|
|
7620
|
-
|
|
7715
|
+
uniffiCallbackInterfaceBinder.register();
|
|
7621
7716
|
uniffiCallbackInterfaceRangeSink.register();
|
|
7622
7717
|
uniffiCallbackInterfacePluginAuthor.register();
|
|
7623
7718
|
uniffiCallbackInterfaceSigningVault.register();
|
|
@@ -7630,62 +7725,60 @@ var trylimbo_issuer_default = Object.freeze({
|
|
|
7630
7725
|
FfiConverterTypeActionKind,
|
|
7631
7726
|
FfiConverterTypeAssertion,
|
|
7632
7727
|
FfiConverterTypeAssetDelivery,
|
|
7728
|
+
FfiConverterTypeAssetFormat,
|
|
7633
7729
|
FfiConverterTypeAssetIssuer,
|
|
7634
7730
|
FfiConverterTypeAssetManifestSpec,
|
|
7635
7731
|
FfiConverterTypeAssetMarker,
|
|
7636
7732
|
FfiConverterTypeAssetOrigin,
|
|
7637
|
-
|
|
7638
|
-
FfiConverterTypeByteRange,
|
|
7733
|
+
FfiConverterTypeBinder,
|
|
7639
7734
|
FfiConverterTypeCode,
|
|
7640
7735
|
FfiConverterTypeComponent,
|
|
7641
7736
|
FfiConverterTypeComponentEvent,
|
|
7642
|
-
FfiConverterTypeCompute,
|
|
7643
|
-
FfiConverterTypeComputeRequest,
|
|
7644
7737
|
FfiConverterTypeConnectOptions,
|
|
7645
7738
|
FfiConverterTypeCreatedOrigin,
|
|
7646
7739
|
FfiConverterTypeCustomAction,
|
|
7740
|
+
FfiConverterTypeDeriveOptions,
|
|
7647
7741
|
FfiConverterTypeEmbedOptions,
|
|
7648
7742
|
FfiConverterTypeFieldViolation,
|
|
7649
7743
|
FfiConverterTypeFileSink,
|
|
7650
7744
|
FfiConverterTypeFileSource,
|
|
7745
|
+
FfiConverterTypeHeldBinder,
|
|
7651
7746
|
FfiConverterTypeIdentity,
|
|
7652
7747
|
FfiConverterTypeIngredient,
|
|
7653
|
-
|
|
7748
|
+
FfiConverterTypeIngredientSource,
|
|
7654
7749
|
FfiConverterTypeInitOptions,
|
|
7655
7750
|
FfiConverterTypeInitOutcome,
|
|
7751
|
+
FfiConverterTypeIsccBinder,
|
|
7656
7752
|
FfiConverterTypeJsonObject,
|
|
7657
7753
|
FfiConverterTypeJsonValue,
|
|
7658
7754
|
FfiConverterTypeMarkOptions,
|
|
7659
7755
|
FfiConverterTypeMarkOutcome,
|
|
7660
7756
|
FfiConverterTypeMemorySink,
|
|
7661
7757
|
FfiConverterTypeMemorySource,
|
|
7662
|
-
FfiConverterTypeMintRequest,
|
|
7663
7758
|
FfiConverterTypeOpenedOrigin,
|
|
7759
|
+
FfiConverterTypeOrigin,
|
|
7664
7760
|
FfiConverterTypeRangeSink,
|
|
7665
7761
|
FfiConverterTypeRangeSource,
|
|
7762
|
+
FfiConverterTypeRegion,
|
|
7666
7763
|
FfiConverterTypeRotationPolicy,
|
|
7667
|
-
FfiConverterTypeScope,
|
|
7668
7764
|
FfiConverterTypeSdkError,
|
|
7669
7765
|
FfiConverterTypeSegmentKind,
|
|
7670
7766
|
FfiConverterTypeSegmentOutcome,
|
|
7671
|
-
FfiConverterTypeSessionKey,
|
|
7672
7767
|
FfiConverterTypeSignOptions,
|
|
7673
7768
|
FfiConverterTypeSignOutcome,
|
|
7674
7769
|
FfiConverterTypeSignOutput,
|
|
7675
7770
|
FfiConverterTypeSignerClient,
|
|
7676
7771
|
FfiConverterTypeSoftBinding,
|
|
7677
|
-
FfiConverterTypeSoftBindingSource,
|
|
7678
|
-
FfiConverterTypeSoftwareAgent,
|
|
7679
7772
|
FfiConverterTypeStandardAction,
|
|
7680
7773
|
FfiConverterTypeStreamDelivery,
|
|
7681
7774
|
FfiConverterTypeStreamIssuer,
|
|
7682
7775
|
FfiConverterTypeStreamManifestSpec,
|
|
7683
|
-
FfiConverterTypeStreamOrigin,
|
|
7684
7776
|
FfiConverterTypeStreamSession,
|
|
7685
7777
|
FfiConverterTypeStreamStart,
|
|
7686
7778
|
FfiConverterTypeThumbnail,
|
|
7687
|
-
|
|
7688
|
-
FfiConverterTypeUrl
|
|
7779
|
+
FfiConverterTypeTimestamp,
|
|
7780
|
+
FfiConverterTypeUrl,
|
|
7781
|
+
FfiConverterTypeVaultPublicKey
|
|
7689
7782
|
}
|
|
7690
7783
|
});
|
|
7691
7784
|
//#endregion
|
|
@@ -7698,4 +7791,4 @@ if (!initialized) {
|
|
|
7698
7791
|
async function uniffiInitAsync() {}
|
|
7699
7792
|
var ffi_trylimbo_sdk_issuer_default = { trylimbo_issuer: trylimbo_issuer_exports };
|
|
7700
7793
|
//#endregion
|
|
7701
|
-
export { Action, ActionDetail, ActionKind, ActionKind_Tags, Action_Tags, Assertion, AssetDelivery, AssetDelivery_Tags, AssetIssuer, AssetManifestSpec, AssetMarker, AssetOrigin, AssetOrigin_Tags,
|
|
7794
|
+
export { Action, ActionDetail, ActionKind, ActionKind_Tags, Action_Tags, Assertion, AssetDelivery, AssetDelivery_Tags, AssetFormat, AssetFormat_Tags, AssetIssuer, AssetManifestSpec, AssetMarker, AssetOrigin, AssetOrigin_Tags, BinderImpl, Code, Component, ComponentEvent, ComponentEvent_Tags, ConnectOptions, CreatedOrigin, CustomAction, DeriveOptions, EmbedOptions, FieldViolation, FileSink, FileSource, HeldBinder, Identity, Ingredient, IngredientSource, IngredientSource_Tags, InitOptions, InitOutcome, IsccBinder, MarkOptions, MarkOutcome, MemorySink, MemorySource, OpenedOrigin, Origin, Origin_Tags, RangeSinkImpl, RangeSourceImpl, Region, RotationPolicy, SdkError, SdkError_Tags, SegmentKind, SegmentOutcome, SignOptions, SignOutcome, SignOutput, SignOutput_Tags, SignerClient, SoftBinding, StandardAction, StreamDelivery, StreamDelivery_Tags, StreamIssuer, StreamManifestSpec, StreamSession, StreamStart, Thumbnail, VaultPublicKey, classifySegment, ffi_trylimbo_sdk_issuer_default as default, embed, uniffiInitAsync };
|