@trylimbo/sdk-issuer 0.2.24 → 0.2.25-canary.38
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 +670 -732
- package/gen/ffi/index.js +894 -896
- package/gen/grpc/buf/validate/validate_pb.d.ts +30 -24
- package/gen/grpc/buf/validate/validate_pb.js +2 -2
- package/gen/grpc/trylimbo/signer/v2/signer_pb.d.ts +763 -781
- package/gen/grpc/trylimbo/signer/v2/signer_pb.js +200 -182
- package/package.json +3 -3
- package/gen/grpc/trylimbo/version/v1/version_pb.d.ts +0 -59
- package/gen/grpc/trylimbo/version/v1/version_pb.js +0 -32
package/gen/ffi/index.js
CHANGED
|
@@ -658,10 +658,17 @@ const UNIFFI_FOREIGN_FUTURE_HANDLE_MAP = new UniffiHandleMap();
|
|
|
658
658
|
function uniffiTraitInterfaceCallAsyncWithError(makeCall, handleSuccess, handleError, isErrorType, lowerError, lowerString, alloc) {
|
|
659
659
|
const settledHolder = { settled: false };
|
|
660
660
|
const abortController = new AbortController();
|
|
661
|
+
let onRejected;
|
|
661
662
|
const promiseHelper = {
|
|
662
663
|
abortController,
|
|
663
664
|
settledHolder,
|
|
664
|
-
promise: makeCall(abortController.signal).finally(() => settledHolder.settled = true).then(
|
|
665
|
+
promise: makeCall(abortController.signal).finally(() => settledHolder.settled = true).then((value) => {
|
|
666
|
+
try {
|
|
667
|
+
handleSuccess(value);
|
|
668
|
+
} catch (error) {
|
|
669
|
+
onRejected(error);
|
|
670
|
+
}
|
|
671
|
+
}, onRejected = (error) => {
|
|
665
672
|
let message = error.message ? error.message : error.toString();
|
|
666
673
|
if (isErrorType(error)) try {
|
|
667
674
|
handleError(1, lowerError(error, alloc));
|
|
@@ -906,16 +913,58 @@ var Cursor = class Cursor {
|
|
|
906
913
|
};
|
|
907
914
|
//#endregion
|
|
908
915
|
//#region ../../../../node_modules/@ubjs/core/dist/esm/ffi-converters.js
|
|
916
|
+
function uniffiInvalid(message) {
|
|
917
|
+
return SdkError.Invalid.new({
|
|
918
|
+
code: Code.InvalidArgument,
|
|
919
|
+
message,
|
|
920
|
+
fieldViolations: []
|
|
921
|
+
});
|
|
922
|
+
}
|
|
923
|
+
const uniffiUnsignedBounds = {
|
|
924
|
+
UInt8: 255,
|
|
925
|
+
UInt16: 65535,
|
|
926
|
+
UInt32: 4294967295
|
|
927
|
+
};
|
|
928
|
+
function uniffiChecked(kind, converter) {
|
|
929
|
+
const unsigned = kind.startsWith("UInt");
|
|
930
|
+
const bits = Number(kind.replace(/\D/g, ""));
|
|
931
|
+
const wide = bits === 64;
|
|
932
|
+
const lower = wide ? unsigned ? BigInt("0") : -(BigInt("1") << BigInt("63")) : unsigned ? 0 : -(2 ** (bits - 1));
|
|
933
|
+
const upper = wide ? unsigned ? (BigInt("1") << BigInt("64")) - BigInt("1") : (BigInt("1") << BigInt("63")) - BigInt("1") : unsigned ? uniffiUnsignedBounds[kind] : 2 ** (bits - 1) - 1;
|
|
934
|
+
return {
|
|
935
|
+
...converter,
|
|
936
|
+
lower: (v, _alloc) => {
|
|
937
|
+
if (wide ? typeof v !== "bigint" : typeof v !== "number" || !Number.isInteger(v)) throw uniffiInvalid(`expected ${wide ? "a bigint" : "an integer number"} for a ${kind}, got ${typeof v === "number" ? v : typeof v}`);
|
|
938
|
+
if (v < lower || v > upper) throw uniffiInvalid(`${v} is outside the range of a ${kind}`);
|
|
939
|
+
return v;
|
|
940
|
+
}
|
|
941
|
+
};
|
|
942
|
+
}
|
|
943
|
+
function uniffiMillis(value) {
|
|
944
|
+
if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 0) throw uniffiInvalid(`a duration is a non-negative whole number of milliseconds, got ${typeof value === "number" ? value : typeof value}`);
|
|
945
|
+
return value;
|
|
946
|
+
}
|
|
947
|
+
function uniffiObject(value) {
|
|
948
|
+
if (value === null || typeof value !== "object" && typeof value !== "function") throw uniffiInvalid(`expected an object, got ${value === null ? "null" : typeof value}`);
|
|
949
|
+
}
|
|
950
|
+
function uniffiBytes(value) {
|
|
951
|
+
if (!(value instanceof ArrayBuffer || value instanceof Uint8Array)) throw uniffiInvalid(`expected an ArrayBuffer or Uint8Array, got ${value === null ? "null" : typeof value}`);
|
|
952
|
+
}
|
|
909
953
|
var AbstractFfiConverterByteArray = class {
|
|
910
954
|
lift(value) {
|
|
911
955
|
const c = Cursor.fromUint8Array(value);
|
|
912
956
|
return this.readFromCursor(c);
|
|
913
957
|
}
|
|
914
958
|
lower(value, alloc) {
|
|
915
|
-
|
|
916
|
-
|
|
917
|
-
|
|
918
|
-
|
|
959
|
+
try {
|
|
960
|
+
const view = alloc(this.allocationSize(value));
|
|
961
|
+
const c = Cursor.fromUint8Array(view);
|
|
962
|
+
this.writeIntoCursor(value, c);
|
|
963
|
+
return view;
|
|
964
|
+
} catch (error) {
|
|
965
|
+
if (error != null && SdkError.instanceOf(error)) throw error;
|
|
966
|
+
throw uniffiInvalid(error instanceof Error ? error.message : String(error));
|
|
967
|
+
}
|
|
919
968
|
}
|
|
920
969
|
};
|
|
921
970
|
/**
|
|
@@ -935,10 +984,14 @@ function makePrimitive(read, write, byteSize) {
|
|
|
935
984
|
writeIntoCursor: write
|
|
936
985
|
};
|
|
937
986
|
}
|
|
938
|
-
|
|
939
|
-
|
|
940
|
-
|
|
941
|
-
|
|
987
|
+
uniffiChecked("Int8", makePrimitive((c) => c.readI8(), (v, c) => c.writeI8(v), 1));
|
|
988
|
+
uniffiChecked("Int16", makePrimitive((c) => c.readI16(), (v, c) => c.writeI16(v), 2));
|
|
989
|
+
uniffiChecked("Int32", makePrimitive((c) => c.readI32(), (v, c) => c.writeI32(v), 4));
|
|
990
|
+
uniffiChecked("Int64", makePrimitive((c) => c.readI64(), (v, c) => c.writeI64(v), 8));
|
|
991
|
+
const FfiConverterUInt8 = uniffiChecked("UInt8", makePrimitive((c) => c.readU8(), (v, c) => c.writeU8(v), 1));
|
|
992
|
+
uniffiChecked("UInt16", makePrimitive((c) => c.readU16(), (v, c) => c.writeU16(v), 2));
|
|
993
|
+
const FfiConverterUInt32 = uniffiChecked("UInt32", makePrimitive((c) => c.readU32(), (v, c) => c.writeU32(v), 4));
|
|
994
|
+
const FfiConverterUInt64 = uniffiChecked("UInt64", makePrimitive((c) => c.readU64(), (v, c) => c.writeU64(v), 8));
|
|
942
995
|
const FfiConverterBool = (() => {
|
|
943
996
|
const read = (c) => c.readBool();
|
|
944
997
|
const write = (v, c) => c.writeBool(v);
|
|
@@ -950,7 +1003,7 @@ const FfiConverterBool = (() => {
|
|
|
950
1003
|
writeIntoCursor: write
|
|
951
1004
|
};
|
|
952
1005
|
})();
|
|
953
|
-
(() => {
|
|
1006
|
+
const FfiConverterDuration = (() => {
|
|
954
1007
|
const msPerSecBigInt = BigInt("1000");
|
|
955
1008
|
const nanosPerMs = 1e6;
|
|
956
1009
|
class FFIConverter extends AbstractFfiConverterByteArray {
|
|
@@ -962,7 +1015,7 @@ const FfiConverterBool = (() => {
|
|
|
962
1015
|
return ms + nanos / nanosPerMs;
|
|
963
1016
|
}
|
|
964
1017
|
writeIntoCursor(value, c) {
|
|
965
|
-
const ms = value
|
|
1018
|
+
const ms = uniffiMillis(value);
|
|
966
1019
|
const secsBigInt = BigInt(Math.trunc(ms)) / msPerSecBigInt;
|
|
967
1020
|
const remainingNanos = ms % 1e3 * nanosPerMs;
|
|
968
1021
|
c.writeU64(secsBigInt);
|
|
@@ -974,7 +1027,7 @@ const FfiConverterBool = (() => {
|
|
|
974
1027
|
}
|
|
975
1028
|
return new FFIConverter();
|
|
976
1029
|
})();
|
|
977
|
-
(() => {
|
|
1030
|
+
const FfiConverterTimestamp = (() => {
|
|
978
1031
|
const msPerSecBigInt = BigInt("1000");
|
|
979
1032
|
const nanosPerMs = 1e6;
|
|
980
1033
|
const msPerSec = 1e3;
|
|
@@ -1084,6 +1137,7 @@ const FfiConverterArrayBuffer = (() => {
|
|
|
1084
1137
|
c.writeBytes(new Uint8Array(value));
|
|
1085
1138
|
}
|
|
1086
1139
|
allocationSize(value) {
|
|
1140
|
+
uniffiBytes(value);
|
|
1087
1141
|
return 4 + value.byteLength;
|
|
1088
1142
|
}
|
|
1089
1143
|
}
|
|
@@ -1157,6 +1211,7 @@ var FfiConverterCallback = class {
|
|
|
1157
1211
|
return this.handleMap.get(value);
|
|
1158
1212
|
}
|
|
1159
1213
|
lower(value, _alloc) {
|
|
1214
|
+
uniffiObject(value);
|
|
1160
1215
|
return this.handleMap.insert(value);
|
|
1161
1216
|
}
|
|
1162
1217
|
readFromCursor(c) {
|
|
@@ -1175,6 +1230,13 @@ var FfiConverterCallback = class {
|
|
|
1175
1230
|
return this.handleMap.remove(handle);
|
|
1176
1231
|
}
|
|
1177
1232
|
};
|
|
1233
|
+
function uniffiTraitInterfaceCall(makeCall, handleSuccess, handleError, lowerString, alloc) {
|
|
1234
|
+
try {
|
|
1235
|
+
handleSuccess(makeCall());
|
|
1236
|
+
} catch (e) {
|
|
1237
|
+
handleError(2, lowerString(e.toString(), alloc));
|
|
1238
|
+
}
|
|
1239
|
+
}
|
|
1178
1240
|
function uniffiTraitInterfaceCallWithError(makeCall, handleSuccess, handleError, isErrorType, lowerError, lowerString, alloc) {
|
|
1179
1241
|
try {
|
|
1180
1242
|
handleSuccess(makeCall());
|
|
@@ -1232,6 +1294,7 @@ var FfiConverterObject = class {
|
|
|
1232
1294
|
pointerConverter.writeIntoCursor(this.lowerHandle(value), c);
|
|
1233
1295
|
}
|
|
1234
1296
|
lowerHandle(value) {
|
|
1297
|
+
uniffiObject(value);
|
|
1235
1298
|
if (this.factory.isConcreteType(value)) return this.factory.clonePointer(value);
|
|
1236
1299
|
else throw new Error("Cannot lower this object to a pointer");
|
|
1237
1300
|
}
|
|
@@ -1246,6 +1309,7 @@ var FfiConverterObjectWithCallbacks = class extends FfiConverterObject {
|
|
|
1246
1309
|
this.handleMap = handleMap;
|
|
1247
1310
|
}
|
|
1248
1311
|
lowerHandle(value) {
|
|
1312
|
+
uniffiObject(value);
|
|
1249
1313
|
if (this.factory.isConcreteType(value)) return super.lowerHandle(value);
|
|
1250
1314
|
return this.handleMap.insert(value);
|
|
1251
1315
|
}
|
|
@@ -1617,12 +1681,12 @@ const DEFINITIONS = {
|
|
|
1617
1681
|
ret: FfiType.Void,
|
|
1618
1682
|
hasRustCallStatus: true
|
|
1619
1683
|
},
|
|
1620
|
-
"
|
|
1684
|
+
"uniffi_trylimbo_sdk_issuer_fn_clone_compute": {
|
|
1621
1685
|
args: [FfiType.Handle],
|
|
1622
1686
|
ret: FfiType.Handle,
|
|
1623
1687
|
hasRustCallStatus: true
|
|
1624
1688
|
},
|
|
1625
|
-
"
|
|
1689
|
+
"uniffi_trylimbo_sdk_issuer_fn_free_compute": {
|
|
1626
1690
|
args: [FfiType.Handle],
|
|
1627
1691
|
ret: FfiType.Void,
|
|
1628
1692
|
hasRustCallStatus: true
|
|
@@ -1647,26 +1711,6 @@ const DEFINITIONS = {
|
|
|
1647
1711
|
ret: FfiType.Void,
|
|
1648
1712
|
hasRustCallStatus: true
|
|
1649
1713
|
},
|
|
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
|
-
},
|
|
1670
1714
|
"uniffi_trylimbo_sdk_issuer_fn_clone_memorysink": {
|
|
1671
1715
|
args: [FfiType.Handle],
|
|
1672
1716
|
ret: FfiType.Handle,
|
|
@@ -1737,8 +1781,8 @@ const DEFINITIONS = {
|
|
|
1737
1781
|
ret: FfiType.Void,
|
|
1738
1782
|
hasRustCallStatus: true
|
|
1739
1783
|
},
|
|
1740
|
-
"
|
|
1741
|
-
args: [FfiType.Reference(FfiType.Struct("
|
|
1784
|
+
"uniffi_trylimbo_sdk_issuer_fn_init_callback_vtable_compute": {
|
|
1785
|
+
args: [FfiType.Reference(FfiType.Struct("VTableCallbackInterfaceTrylimboIssuerCompute"))],
|
|
1742
1786
|
ret: FfiType.Void,
|
|
1743
1787
|
hasRustCallStatus: false
|
|
1744
1788
|
},
|
|
@@ -1767,6 +1811,15 @@ const DEFINITIONS = {
|
|
|
1767
1811
|
ret: FfiType.Handle,
|
|
1768
1812
|
hasRustCallStatus: false
|
|
1769
1813
|
},
|
|
1814
|
+
"uniffi_trylimbo_sdk_issuer_fn_func_compute_soft_binding": {
|
|
1815
|
+
args: [
|
|
1816
|
+
FfiType.RustBuffer,
|
|
1817
|
+
FfiType.Handle,
|
|
1818
|
+
FfiType.RustBuffer
|
|
1819
|
+
],
|
|
1820
|
+
ret: FfiType.Handle,
|
|
1821
|
+
hasRustCallStatus: false
|
|
1822
|
+
},
|
|
1770
1823
|
"uniffi_trylimbo_sdk_issuer_fn_func_embed": {
|
|
1771
1824
|
args: [
|
|
1772
1825
|
FfiType.Handle,
|
|
@@ -1800,6 +1853,7 @@ const DEFINITIONS = {
|
|
|
1800
1853
|
},
|
|
1801
1854
|
"uniffi_trylimbo_sdk_issuer_fn_method_assetmarker_mark": {
|
|
1802
1855
|
args: [
|
|
1856
|
+
FfiType.Handle,
|
|
1803
1857
|
FfiType.Handle,
|
|
1804
1858
|
FfiType.Handle,
|
|
1805
1859
|
FfiType.RustBuffer
|
|
@@ -1807,12 +1861,13 @@ const DEFINITIONS = {
|
|
|
1807
1861
|
ret: FfiType.Handle,
|
|
1808
1862
|
hasRustCallStatus: false
|
|
1809
1863
|
},
|
|
1810
|
-
"
|
|
1811
|
-
args: [
|
|
1812
|
-
|
|
1813
|
-
|
|
1814
|
-
|
|
1815
|
-
|
|
1864
|
+
"uniffi_trylimbo_sdk_issuer_fn_method_compute_alg": {
|
|
1865
|
+
args: [FfiType.Handle],
|
|
1866
|
+
ret: FfiType.RustBuffer,
|
|
1867
|
+
hasRustCallStatus: true
|
|
1868
|
+
},
|
|
1869
|
+
"uniffi_trylimbo_sdk_issuer_fn_method_compute_compute": {
|
|
1870
|
+
args: [FfiType.Handle, FfiType.RustBuffer],
|
|
1816
1871
|
ret: FfiType.Handle,
|
|
1817
1872
|
hasRustCallStatus: false
|
|
1818
1873
|
},
|
|
@@ -1873,36 +1928,13 @@ const DEFINITIONS = {
|
|
|
1873
1928
|
ret: FfiType.Handle,
|
|
1874
1929
|
hasRustCallStatus: false
|
|
1875
1930
|
},
|
|
1876
|
-
"
|
|
1931
|
+
"uniffi_trylimbo_sdk_issuer_fn_constructor_memorysink_new": {
|
|
1877
1932
|
args: [FfiType.RustBuffer],
|
|
1878
1933
|
ret: FfiType.Handle,
|
|
1879
1934
|
hasRustCallStatus: true
|
|
1880
1935
|
},
|
|
1881
|
-
"
|
|
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
|
-
},
|
|
1904
|
-
"uniffi_trylimbo_sdk_issuer_fn_constructor_memorysink_new": {
|
|
1905
|
-
args: [FfiType.RustBuffer],
|
|
1936
|
+
"uniffi_trylimbo_sdk_issuer_fn_constructor_memorysink_with_capacity": {
|
|
1937
|
+
args: [FfiType.RustBuffer, FfiType.UInt64],
|
|
1906
1938
|
ret: FfiType.Handle,
|
|
1907
1939
|
hasRustCallStatus: true
|
|
1908
1940
|
},
|
|
@@ -2052,6 +2084,11 @@ const DEFINITIONS = {
|
|
|
2052
2084
|
ret: FfiType.UInt16,
|
|
2053
2085
|
hasRustCallStatus: false
|
|
2054
2086
|
},
|
|
2087
|
+
"uniffi_trylimbo_sdk_issuer_checksum_func_compute_soft_binding": {
|
|
2088
|
+
args: [],
|
|
2089
|
+
ret: FfiType.UInt16,
|
|
2090
|
+
hasRustCallStatus: false
|
|
2091
|
+
},
|
|
2055
2092
|
"uniffi_trylimbo_sdk_issuer_checksum_func_embed": {
|
|
2056
2093
|
args: [],
|
|
2057
2094
|
ret: FfiType.UInt16,
|
|
@@ -2077,7 +2114,12 @@ const DEFINITIONS = {
|
|
|
2077
2114
|
ret: FfiType.UInt16,
|
|
2078
2115
|
hasRustCallStatus: false
|
|
2079
2116
|
},
|
|
2080
|
-
"
|
|
2117
|
+
"uniffi_trylimbo_sdk_issuer_checksum_method_compute_alg": {
|
|
2118
|
+
args: [],
|
|
2119
|
+
ret: FfiType.UInt16,
|
|
2120
|
+
hasRustCallStatus: false
|
|
2121
|
+
},
|
|
2122
|
+
"uniffi_trylimbo_sdk_issuer_checksum_method_compute_compute": {
|
|
2081
2123
|
args: [],
|
|
2082
2124
|
ret: FfiType.UInt16,
|
|
2083
2125
|
hasRustCallStatus: false
|
|
@@ -2127,27 +2169,12 @@ const DEFINITIONS = {
|
|
|
2127
2169
|
ret: FfiType.UInt16,
|
|
2128
2170
|
hasRustCallStatus: false
|
|
2129
2171
|
},
|
|
2130
|
-
"
|
|
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": {
|
|
2172
|
+
"uniffi_trylimbo_sdk_issuer_checksum_constructor_memorysink_new": {
|
|
2146
2173
|
args: [],
|
|
2147
2174
|
ret: FfiType.UInt16,
|
|
2148
2175
|
hasRustCallStatus: false
|
|
2149
2176
|
},
|
|
2150
|
-
"
|
|
2177
|
+
"uniffi_trylimbo_sdk_issuer_checksum_constructor_memorysink_with_capacity": {
|
|
2151
2178
|
args: [],
|
|
2152
2179
|
ret: FfiType.UInt16,
|
|
2153
2180
|
hasRustCallStatus: false
|
|
@@ -2264,14 +2291,19 @@ const DEFINITIONS = {
|
|
|
2264
2291
|
ret: FfiType.Void,
|
|
2265
2292
|
hasRustCallStatus: false
|
|
2266
2293
|
},
|
|
2294
|
+
"CallbackInterfaceTrylimboIssuerComputeMethod0": {
|
|
2295
|
+
args: [FfiType.Handle],
|
|
2296
|
+
ret: FfiType.RustBuffer,
|
|
2297
|
+
hasRustCallStatus: true,
|
|
2298
|
+
outReturn: true
|
|
2299
|
+
},
|
|
2267
2300
|
"ForeignFutureCompleterust_buffer": {
|
|
2268
2301
|
args: [FfiType.Handle, FfiType.Struct("ForeignFutureResultRustBuffer")],
|
|
2269
2302
|
ret: FfiType.Void,
|
|
2270
2303
|
hasRustCallStatus: false
|
|
2271
2304
|
},
|
|
2272
|
-
"
|
|
2305
|
+
"CallbackInterfaceTrylimboIssuerComputeMethod1": {
|
|
2273
2306
|
args: [
|
|
2274
|
-
FfiType.Handle,
|
|
2275
2307
|
FfiType.Handle,
|
|
2276
2308
|
FfiType.RustBuffer,
|
|
2277
2309
|
FfiType.Callback("ForeignFutureCompleterust_buffer"),
|
|
@@ -2281,12 +2313,12 @@ const DEFINITIONS = {
|
|
|
2281
2313
|
hasRustCallStatus: false,
|
|
2282
2314
|
outReturn: true
|
|
2283
2315
|
},
|
|
2284
|
-
"
|
|
2316
|
+
"CallbackInterfaceCloneTrylimboIssuer_Compute": {
|
|
2285
2317
|
args: [FfiType.Handle],
|
|
2286
2318
|
ret: FfiType.Handle,
|
|
2287
2319
|
hasRustCallStatus: false
|
|
2288
2320
|
},
|
|
2289
|
-
"
|
|
2321
|
+
"CallbackInterfaceFreeTrylimboIssuer_Compute": {
|
|
2290
2322
|
args: [FfiType.Handle],
|
|
2291
2323
|
ret: FfiType.Void,
|
|
2292
2324
|
hasRustCallStatus: false
|
|
@@ -2441,7 +2473,7 @@ const DEFINITIONS = {
|
|
|
2441
2473
|
"CallbackInterfaceTrylimboIssuerSigningVaultMethod0": {
|
|
2442
2474
|
args: [
|
|
2443
2475
|
FfiType.Handle,
|
|
2444
|
-
FfiType.
|
|
2476
|
+
FfiType.RustBuffer,
|
|
2445
2477
|
FfiType.Callback("ForeignFutureCompleterust_buffer"),
|
|
2446
2478
|
FfiType.Handle
|
|
2447
2479
|
],
|
|
@@ -2498,18 +2530,22 @@ const DEFINITIONS = {
|
|
|
2498
2530
|
name: "call_status",
|
|
2499
2531
|
type: FfiType.RustCallStatus
|
|
2500
2532
|
}],
|
|
2501
|
-
"
|
|
2533
|
+
"VTableCallbackInterfaceTrylimboIssuerCompute": [
|
|
2502
2534
|
{
|
|
2503
2535
|
name: "uniffi_free",
|
|
2504
|
-
type: FfiType.Callback("
|
|
2536
|
+
type: FfiType.Callback("CallbackInterfaceFreeTrylimboIssuer_Compute")
|
|
2505
2537
|
},
|
|
2506
2538
|
{
|
|
2507
2539
|
name: "uniffi_clone",
|
|
2508
|
-
type: FfiType.Callback("
|
|
2540
|
+
type: FfiType.Callback("CallbackInterfaceCloneTrylimboIssuer_Compute")
|
|
2541
|
+
},
|
|
2542
|
+
{
|
|
2543
|
+
name: "alg",
|
|
2544
|
+
type: FfiType.Callback("CallbackInterfaceTrylimboIssuerComputeMethod0")
|
|
2509
2545
|
},
|
|
2510
2546
|
{
|
|
2511
|
-
name: "
|
|
2512
|
-
type: FfiType.Callback("
|
|
2547
|
+
name: "compute",
|
|
2548
|
+
type: FfiType.Callback("CallbackInterfaceTrylimboIssuerComputeMethod1")
|
|
2513
2549
|
}
|
|
2514
2550
|
],
|
|
2515
2551
|
"ForeignFutureResultU64": [{
|
|
@@ -2641,75 +2677,77 @@ var trylimbo_issuer_exports = /* @__PURE__ */ __exportAll({
|
|
|
2641
2677
|
Assertion: () => Assertion,
|
|
2642
2678
|
AssetDelivery: () => AssetDelivery,
|
|
2643
2679
|
AssetDelivery_Tags: () => AssetDelivery_Tags,
|
|
2644
|
-
AssetFormat: () => AssetFormat,
|
|
2645
|
-
AssetFormat_Tags: () => AssetFormat_Tags,
|
|
2646
2680
|
AssetIssuer: () => AssetIssuer,
|
|
2647
2681
|
AssetManifestSpec: () => AssetManifestSpec,
|
|
2648
2682
|
AssetMarker: () => AssetMarker,
|
|
2649
2683
|
AssetOrigin: () => AssetOrigin,
|
|
2650
2684
|
AssetOrigin_Tags: () => AssetOrigin_Tags,
|
|
2651
|
-
|
|
2685
|
+
Block: () => Block,
|
|
2686
|
+
ByteRange: () => ByteRange,
|
|
2652
2687
|
Code: () => Code,
|
|
2653
2688
|
Component: () => Component,
|
|
2654
2689
|
ComponentEvent: () => ComponentEvent,
|
|
2655
2690
|
ComponentEvent_Tags: () => ComponentEvent_Tags,
|
|
2691
|
+
ComputeImpl: () => ComputeImpl,
|
|
2692
|
+
ComputeRequest: () => ComputeRequest,
|
|
2656
2693
|
ConnectOptions: () => ConnectOptions,
|
|
2657
2694
|
CreatedOrigin: () => CreatedOrigin,
|
|
2658
2695
|
CustomAction: () => CustomAction,
|
|
2659
|
-
DeriveOptions: () => DeriveOptions,
|
|
2660
2696
|
EmbedOptions: () => EmbedOptions,
|
|
2661
2697
|
FieldViolation: () => FieldViolation,
|
|
2662
2698
|
FileSink: () => FileSink,
|
|
2663
2699
|
FileSource: () => FileSource,
|
|
2664
|
-
HeldBinder: () => HeldBinder,
|
|
2665
2700
|
Identity: () => Identity,
|
|
2666
2701
|
Ingredient: () => Ingredient,
|
|
2667
|
-
|
|
2668
|
-
|
|
2702
|
+
IngredientKind: () => IngredientKind,
|
|
2703
|
+
IngredientKind_Tags: () => IngredientKind_Tags,
|
|
2669
2704
|
InitOptions: () => InitOptions,
|
|
2670
2705
|
InitOutcome: () => InitOutcome,
|
|
2671
|
-
IsccBinder: () => IsccBinder,
|
|
2672
2706
|
MarkOptions: () => MarkOptions,
|
|
2673
2707
|
MarkOutcome: () => MarkOutcome,
|
|
2674
2708
|
MemorySink: () => MemorySink,
|
|
2675
2709
|
MemorySource: () => MemorySource,
|
|
2710
|
+
MintRequest: () => MintRequest,
|
|
2676
2711
|
OpenedOrigin: () => OpenedOrigin,
|
|
2677
|
-
Origin: () => Origin,
|
|
2678
|
-
Origin_Tags: () => Origin_Tags,
|
|
2679
2712
|
RangeSinkImpl: () => RangeSinkImpl,
|
|
2680
2713
|
RangeSourceImpl: () => RangeSourceImpl,
|
|
2681
|
-
Region: () => Region,
|
|
2682
2714
|
RotationPolicy: () => RotationPolicy,
|
|
2715
|
+
Scope: () => Scope,
|
|
2683
2716
|
SdkError: () => SdkError,
|
|
2684
2717
|
SdkError_Tags: () => SdkError_Tags,
|
|
2685
2718
|
SegmentKind: () => SegmentKind,
|
|
2686
2719
|
SegmentOutcome: () => SegmentOutcome,
|
|
2720
|
+
SessionKey: () => SessionKey,
|
|
2687
2721
|
SignOptions: () => SignOptions,
|
|
2688
2722
|
SignOutcome: () => SignOutcome,
|
|
2689
2723
|
SignOutput: () => SignOutput,
|
|
2690
2724
|
SignOutput_Tags: () => SignOutput_Tags,
|
|
2691
2725
|
SignerClient: () => SignerClient,
|
|
2692
2726
|
SoftBinding: () => SoftBinding,
|
|
2727
|
+
SoftBindingSource: () => SoftBindingSource,
|
|
2728
|
+
SoftBindingSource_Tags: () => SoftBindingSource_Tags,
|
|
2729
|
+
SoftwareAgent: () => SoftwareAgent,
|
|
2693
2730
|
StandardAction: () => StandardAction,
|
|
2694
2731
|
StreamDelivery: () => StreamDelivery,
|
|
2695
|
-
StreamDelivery_Tags: () => StreamDelivery_Tags,
|
|
2696
2732
|
StreamIssuer: () => StreamIssuer,
|
|
2697
2733
|
StreamManifestSpec: () => StreamManifestSpec,
|
|
2734
|
+
StreamOrigin: () => StreamOrigin,
|
|
2735
|
+
StreamOrigin_Tags: () => StreamOrigin_Tags,
|
|
2698
2736
|
StreamSession: () => StreamSession,
|
|
2699
2737
|
StreamStart: () => StreamStart,
|
|
2700
2738
|
Thumbnail: () => Thumbnail,
|
|
2701
|
-
|
|
2739
|
+
Timespan: () => Timespan,
|
|
2702
2740
|
classifySegment: () => classifySegment,
|
|
2741
|
+
computeSoftBinding: () => computeSoftBinding,
|
|
2703
2742
|
default: () => trylimbo_issuer_default,
|
|
2704
2743
|
embed: () => embed
|
|
2705
2744
|
});
|
|
2706
2745
|
const uniffiCaller = new UniffiRustCaller(() => ({ code: 0 }));
|
|
2707
2746
|
const uniffiIsDebug = typeof process !== "object" || process?.env?.NODE_ENV !== "production" || false;
|
|
2708
2747
|
/**
|
|
2709
|
-
* Classify a fragmented-MP4 segment
|
|
2710
|
-
*
|
|
2711
|
-
*
|
|
2712
|
-
* [`StreamSession::sign`](stream::StreamSession::sign) without hand-parsing ISOBMFF itself.
|
|
2748
|
+
* Classify a fragmented-MP4 segment as init, media or unknown (`moov` vs `moof`), so a streaming
|
|
2749
|
+
* consumer routes each segment to `StreamIssuer.init` or `StreamSession.sign` without parsing
|
|
2750
|
+
* ISOBMFF itself.
|
|
2713
2751
|
*
|
|
2714
2752
|
* Async because it reads, and reading is the caller's storage: the two windows below may each
|
|
2715
2753
|
* be a round trip. It stays off the island, uniquely among the read-path entry points, because
|
|
@@ -2738,22 +2776,36 @@ async function classifySegment(source, asyncOpts_) {
|
|
|
2738
2776
|
}
|
|
2739
2777
|
}
|
|
2740
2778
|
/**
|
|
2741
|
-
*
|
|
2742
|
-
*
|
|
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.
|
|
2779
|
+
* The values this SDK computes for `alg` over an asset, `[]` when it finds none. `format` is
|
|
2780
|
+
* the asset's media type; omitted, the bytes name it.
|
|
2748
2781
|
*
|
|
2749
|
-
* #
|
|
2782
|
+
* # Errors
|
|
2750
2783
|
*
|
|
2751
|
-
*
|
|
2752
|
-
*
|
|
2753
|
-
|
|
2754
|
-
|
|
2755
|
-
|
|
2756
|
-
|
|
2784
|
+
* An algorithm this SDK computes no value of, a `format` that is no media type or that the bytes
|
|
2785
|
+
* contradict, an unreadable source, or no trustworthy answer.
|
|
2786
|
+
*/
|
|
2787
|
+
async function computeSoftBinding(alg, source, format = void 0, asyncOpts_) {
|
|
2788
|
+
const __stack = uniffiIsDebug ? (/* @__PURE__ */ new Error()).stack : void 0;
|
|
2789
|
+
try {
|
|
2790
|
+
return await uniffiRustCallAsync(uniffiCaller, () => {
|
|
2791
|
+
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));
|
|
2792
|
+
}, 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) => {
|
|
2793
|
+
try {
|
|
2794
|
+
return FfiConverterSequenceTypeBlock.lift(__rb);
|
|
2795
|
+
} finally {
|
|
2796
|
+
getter().rustbuffer_free(__rb);
|
|
2797
|
+
}
|
|
2798
|
+
}, FfiConverterString.lift.bind(FfiConverterString), asyncOpts_, FfiConverterTypeSdkError.lift.bind(FfiConverterTypeSdkError));
|
|
2799
|
+
} catch (__error) {
|
|
2800
|
+
if (uniffiIsDebug && __error instanceof Error) __error.stack = __stack;
|
|
2801
|
+
throw __error;
|
|
2802
|
+
}
|
|
2803
|
+
}
|
|
2804
|
+
/**
|
|
2805
|
+
* Embed `sidecar`, the signed manifest a sign returned, into the asset `sink` holds, writing the
|
|
2806
|
+
* composed result back through `sink`.
|
|
2807
|
+
* `plugins` resolve a non-c2pa format (e.g. MXF) as `AssetIssuer.sign` resolves them; none is a
|
|
2808
|
+
* c2pa-native embed. No signer round trip.
|
|
2757
2809
|
*
|
|
2758
2810
|
* # Errors
|
|
2759
2811
|
*
|
|
@@ -2761,11 +2813,11 @@ async function classifySegment(source, asyncOpts_) {
|
|
|
2761
2813
|
* authoring/`locate` disagrees after the write, or the c2pa handler can't
|
|
2762
2814
|
* parse/splice the asset.
|
|
2763
2815
|
*/
|
|
2764
|
-
async function embed(sink,
|
|
2816
|
+
async function embed(sink, sidecar, options, plugins = [], asyncOpts_) {
|
|
2765
2817
|
const __stack = uniffiIsDebug ? (/* @__PURE__ */ new Error()).stack : void 0;
|
|
2766
2818
|
try {
|
|
2767
2819
|
return await uniffiRustCallAsync(uniffiCaller, () => {
|
|
2768
|
-
return getter().uniffi_trylimbo_sdk_issuer_fn_func_embed(FfiConverterTypeRangeSink.lower(sink, getter().rustbuffer_alloc), FfiConverterArrayBuffer.lower(
|
|
2820
|
+
return getter().uniffi_trylimbo_sdk_issuer_fn_func_embed(FfiConverterTypeRangeSink.lower(sink, getter().rustbuffer_alloc), FfiConverterArrayBuffer.lower(sidecar, getter().rustbuffer_alloc), FfiConverterTypeEmbedOptions.lower(options, getter().rustbuffer_alloc), FfiConverterSequenceTypePluginAuthor.lower(plugins, getter().rustbuffer_alloc));
|
|
2769
2821
|
}, 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));
|
|
2770
2822
|
} catch (__error) {
|
|
2771
2823
|
if (uniffiIsDebug && __error instanceof Error) __error.stack = __stack;
|
|
@@ -2786,7 +2838,34 @@ const FfiConverterString = uniffiCreateFfiConverterString((() => {
|
|
|
2786
2838
|
readStringFromBuffer: (buf, offset, length) => decoder.decode(new Uint8Array(buf.arrayBuffer, offset, length))
|
|
2787
2839
|
};
|
|
2788
2840
|
})());
|
|
2789
|
-
|
|
2841
|
+
/**
|
|
2842
|
+
* Generated factory for {@link SoftwareAgent} record objects.
|
|
2843
|
+
*/
|
|
2844
|
+
const SoftwareAgent = (() => {
|
|
2845
|
+
const defaults = () => ({});
|
|
2846
|
+
const create = (() => {
|
|
2847
|
+
return uniffiCreateRecord(defaults);
|
|
2848
|
+
})();
|
|
2849
|
+
return Object.freeze({
|
|
2850
|
+
create,
|
|
2851
|
+
new: create,
|
|
2852
|
+
defaults: () => Object.freeze(defaults())
|
|
2853
|
+
});
|
|
2854
|
+
})();
|
|
2855
|
+
const FfiConverterTypeSoftwareAgent = (() => {
|
|
2856
|
+
class FFIConverter extends AbstractFfiConverterByteArray {
|
|
2857
|
+
readFromCursor(c) {
|
|
2858
|
+
return { name: FfiConverterString.readFromCursor(c) };
|
|
2859
|
+
}
|
|
2860
|
+
writeIntoCursor(value, c) {
|
|
2861
|
+
FfiConverterString.writeIntoCursor(value.name, c);
|
|
2862
|
+
}
|
|
2863
|
+
allocationSize(value) {
|
|
2864
|
+
return FfiConverterString.allocationSize(value.name);
|
|
2865
|
+
}
|
|
2866
|
+
}
|
|
2867
|
+
return new FFIConverter();
|
|
2868
|
+
})();
|
|
2790
2869
|
const FfiConverterTypeUrl = FfiConverterString;
|
|
2791
2870
|
/**
|
|
2792
2871
|
* Generated factory for {@link ActionDetail} record objects.
|
|
@@ -2811,20 +2890,20 @@ const FfiConverterTypeActionDetail = (() => {
|
|
|
2811
2890
|
class FFIConverter extends AbstractFfiConverterByteArray {
|
|
2812
2891
|
readFromCursor(c) {
|
|
2813
2892
|
return {
|
|
2814
|
-
when:
|
|
2815
|
-
softwareAgent:
|
|
2893
|
+
when: FfiConverterOptionalTimestamp.readFromCursor(c),
|
|
2894
|
+
softwareAgent: FfiConverterOptionalTypeSoftwareAgent.readFromCursor(c),
|
|
2816
2895
|
description: FfiConverterOptionalString.readFromCursor(c),
|
|
2817
2896
|
sourceType: FfiConverterOptionalTypeUrl.readFromCursor(c)
|
|
2818
2897
|
};
|
|
2819
2898
|
}
|
|
2820
2899
|
writeIntoCursor(value, c) {
|
|
2821
|
-
|
|
2822
|
-
|
|
2900
|
+
FfiConverterOptionalTimestamp.writeIntoCursor(value.when, c);
|
|
2901
|
+
FfiConverterOptionalTypeSoftwareAgent.writeIntoCursor(value.softwareAgent, c);
|
|
2823
2902
|
FfiConverterOptionalString.writeIntoCursor(value.description, c);
|
|
2824
2903
|
FfiConverterOptionalTypeUrl.writeIntoCursor(value.sourceType, c);
|
|
2825
2904
|
}
|
|
2826
2905
|
allocationSize(value) {
|
|
2827
|
-
return
|
|
2906
|
+
return FfiConverterOptionalTimestamp.allocationSize(value.when) + FfiConverterOptionalTypeSoftwareAgent.allocationSize(value.softwareAgent) + FfiConverterOptionalString.allocationSize(value.description) + FfiConverterOptionalTypeUrl.allocationSize(value.sourceType);
|
|
2828
2907
|
}
|
|
2829
2908
|
}
|
|
2830
2909
|
return new FFIConverter();
|
|
@@ -2866,7 +2945,11 @@ const FfiConverterTypeAssertion = (() => {
|
|
|
2866
2945
|
* Generated factory for {@link CreatedOrigin} record objects.
|
|
2867
2946
|
*/
|
|
2868
2947
|
const CreatedOrigin = (() => {
|
|
2869
|
-
const defaults = () => ({
|
|
2948
|
+
const defaults = () => ({
|
|
2949
|
+
when: void 0,
|
|
2950
|
+
softwareAgent: void 0,
|
|
2951
|
+
description: void 0
|
|
2952
|
+
});
|
|
2870
2953
|
const create = (() => {
|
|
2871
2954
|
return uniffiCreateRecord(defaults);
|
|
2872
2955
|
})();
|
|
@@ -2881,25 +2964,25 @@ const FfiConverterTypeCreatedOrigin = (() => {
|
|
|
2881
2964
|
readFromCursor(c) {
|
|
2882
2965
|
return {
|
|
2883
2966
|
sourceType: FfiConverterTypeUrl.readFromCursor(c),
|
|
2884
|
-
|
|
2967
|
+
when: FfiConverterOptionalTimestamp.readFromCursor(c),
|
|
2968
|
+
softwareAgent: FfiConverterOptionalTypeSoftwareAgent.readFromCursor(c),
|
|
2969
|
+
description: FfiConverterOptionalString.readFromCursor(c)
|
|
2885
2970
|
};
|
|
2886
2971
|
}
|
|
2887
2972
|
writeIntoCursor(value, c) {
|
|
2888
2973
|
FfiConverterTypeUrl.writeIntoCursor(value.sourceType, c);
|
|
2889
|
-
|
|
2974
|
+
FfiConverterOptionalTimestamp.writeIntoCursor(value.when, c);
|
|
2975
|
+
FfiConverterOptionalTypeSoftwareAgent.writeIntoCursor(value.softwareAgent, c);
|
|
2976
|
+
FfiConverterOptionalString.writeIntoCursor(value.description, c);
|
|
2890
2977
|
}
|
|
2891
2978
|
allocationSize(value) {
|
|
2892
|
-
return FfiConverterTypeUrl.allocationSize(value.sourceType) +
|
|
2979
|
+
return FfiConverterTypeUrl.allocationSize(value.sourceType) + FfiConverterOptionalTimestamp.allocationSize(value.when) + FfiConverterOptionalTypeSoftwareAgent.allocationSize(value.softwareAgent) + FfiConverterOptionalString.allocationSize(value.description);
|
|
2893
2980
|
}
|
|
2894
2981
|
}
|
|
2895
2982
|
return new FFIConverter();
|
|
2896
2983
|
})();
|
|
2897
2984
|
/**
|
|
2898
2985
|
* 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.
|
|
2903
2986
|
*/
|
|
2904
2987
|
let Code = /* @__PURE__ */ function(Code) {
|
|
2905
2988
|
Code[Code["Canceled"] = 0] = "Canceled";
|
|
@@ -3356,160 +3439,68 @@ const uniffiCallbackInterfaceRangeSource = {
|
|
|
3356
3439
|
getter().uniffi_trylimbo_sdk_issuer_fn_init_callback_vtable_rangesource(uniffiCallbackInterfaceRangeSource.vtable);
|
|
3357
3440
|
}
|
|
3358
3441
|
};
|
|
3359
|
-
let
|
|
3360
|
-
|
|
3361
|
-
|
|
3362
|
-
return
|
|
3442
|
+
let IngredientKind_Tags = /* @__PURE__ */ function(IngredientKind_Tags) {
|
|
3443
|
+
IngredientKind_Tags["Asset"] = "Asset";
|
|
3444
|
+
IngredientKind_Tags["Descriptor"] = "Descriptor";
|
|
3445
|
+
return IngredientKind_Tags;
|
|
3363
3446
|
}({});
|
|
3364
3447
|
/**
|
|
3365
|
-
*
|
|
3366
|
-
* caller makes by name, not what happens when they say nothing.
|
|
3448
|
+
* What an ingredient is: an asset whose manifest is read, or a description.
|
|
3367
3449
|
*/
|
|
3368
|
-
const
|
|
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 = (() => {
|
|
3450
|
+
const IngredientKind = (() => {
|
|
3464
3451
|
/**
|
|
3465
3452
|
* The ingredient asset, read in place through `source`; the asset itself never crosses the
|
|
3466
3453
|
* wire, only the manifest it carries and what validating it found.
|
|
3454
|
+
* `format` is the asset's media type; `None` reads it from the leading bytes.
|
|
3467
3455
|
*/
|
|
3468
3456
|
class Asset_ extends UniffiEnum {
|
|
3469
3457
|
/**
|
|
3470
3458
|
* @private
|
|
3471
3459
|
* This field is private and should not be used, use `tag` instead.
|
|
3472
3460
|
*/
|
|
3473
|
-
[uniffiTypeNameSymbol] = "
|
|
3461
|
+
[uniffiTypeNameSymbol] = "IngredientKind";
|
|
3474
3462
|
tag = "Asset";
|
|
3475
3463
|
inner;
|
|
3476
3464
|
constructor(inner) {
|
|
3477
|
-
super("
|
|
3465
|
+
super("IngredientKind", "Asset");
|
|
3478
3466
|
this.inner = Object.freeze(inner);
|
|
3479
3467
|
}
|
|
3480
|
-
static new(
|
|
3481
|
-
|
|
3482
|
-
|
|
3468
|
+
static new = (() => {
|
|
3469
|
+
const defaults = () => ({
|
|
3470
|
+
format: void 0,
|
|
3471
|
+
discoveredBy: []
|
|
3472
|
+
});
|
|
3473
|
+
const create = uniffiCreateRecord(defaults);
|
|
3474
|
+
return (partial) => new Asset_(create(partial));
|
|
3475
|
+
})();
|
|
3483
3476
|
static instanceOf(obj) {
|
|
3484
3477
|
return obj.tag === "Asset";
|
|
3485
3478
|
}
|
|
3486
3479
|
}
|
|
3487
3480
|
/**
|
|
3488
|
-
* No asset: the ingredient is described by its title and
|
|
3481
|
+
* No asset: the ingredient is described by its title and its media type alone.
|
|
3489
3482
|
*/
|
|
3490
3483
|
class Descriptor_ extends UniffiEnum {
|
|
3491
3484
|
/**
|
|
3492
3485
|
* @private
|
|
3493
3486
|
* This field is private and should not be used, use `tag` instead.
|
|
3494
3487
|
*/
|
|
3495
|
-
[uniffiTypeNameSymbol] = "
|
|
3488
|
+
[uniffiTypeNameSymbol] = "IngredientKind";
|
|
3496
3489
|
tag = "Descriptor";
|
|
3497
3490
|
inner;
|
|
3498
3491
|
constructor(inner) {
|
|
3499
|
-
super("
|
|
3492
|
+
super("IngredientKind", "Descriptor");
|
|
3500
3493
|
this.inner = Object.freeze(inner);
|
|
3501
3494
|
}
|
|
3502
|
-
static new
|
|
3503
|
-
|
|
3504
|
-
|
|
3505
|
-
return (partial) => new Descriptor_(create(partial));
|
|
3506
|
-
})();
|
|
3495
|
+
static new(inner) {
|
|
3496
|
+
return new Descriptor_(inner);
|
|
3497
|
+
}
|
|
3507
3498
|
static instanceOf(obj) {
|
|
3508
3499
|
return obj.tag === "Descriptor";
|
|
3509
3500
|
}
|
|
3510
3501
|
}
|
|
3511
3502
|
function instanceOf(obj) {
|
|
3512
|
-
return obj[uniffiTypeNameSymbol] === "
|
|
3503
|
+
return obj[uniffiTypeNameSymbol] === "IngredientKind";
|
|
3513
3504
|
}
|
|
3514
3505
|
return Object.freeze({
|
|
3515
3506
|
instanceOf,
|
|
@@ -3517,15 +3508,16 @@ const IngredientSource = (() => {
|
|
|
3517
3508
|
Descriptor: Descriptor_
|
|
3518
3509
|
});
|
|
3519
3510
|
})();
|
|
3520
|
-
const
|
|
3511
|
+
const FfiConverterTypeIngredientKind = (() => {
|
|
3521
3512
|
class FFIConverter extends AbstractFfiConverterByteArray {
|
|
3522
3513
|
readFromCursor(c) {
|
|
3523
3514
|
switch (c.readI32()) {
|
|
3524
|
-
case 1: return new
|
|
3515
|
+
case 1: return new IngredientKind.Asset({
|
|
3525
3516
|
source: FfiConverterTypeRangeSource.readFromCursor(c),
|
|
3526
|
-
format:
|
|
3517
|
+
format: FfiConverterOptionalString.readFromCursor(c),
|
|
3518
|
+
discoveredBy: FfiConverterSequenceString.readFromCursor(c)
|
|
3527
3519
|
});
|
|
3528
|
-
case 2: return new
|
|
3520
|
+
case 2: return new IngredientKind.Descriptor({ format: FfiConverterString.readFromCursor(c) });
|
|
3529
3521
|
default: throw new UniffiInternalError.UnexpectedEnumCase();
|
|
3530
3522
|
}
|
|
3531
3523
|
}
|
|
@@ -3535,13 +3527,14 @@ const FfiConverterTypeIngredientSource = (() => {
|
|
|
3535
3527
|
c.writeI32(1);
|
|
3536
3528
|
const inner = value.inner;
|
|
3537
3529
|
FfiConverterTypeRangeSource.writeIntoCursor(inner.source, c);
|
|
3538
|
-
|
|
3530
|
+
FfiConverterOptionalString.writeIntoCursor(inner.format, c);
|
|
3531
|
+
FfiConverterSequenceString.writeIntoCursor(inner.discoveredBy, c);
|
|
3539
3532
|
return;
|
|
3540
3533
|
}
|
|
3541
3534
|
case "Descriptor": {
|
|
3542
3535
|
c.writeI32(2);
|
|
3543
3536
|
const inner = value.inner;
|
|
3544
|
-
|
|
3537
|
+
FfiConverterString.writeIntoCursor(inner.format, c);
|
|
3545
3538
|
return;
|
|
3546
3539
|
}
|
|
3547
3540
|
default: throw new UniffiInternalError.UnexpectedEnumCase();
|
|
@@ -3553,13 +3546,14 @@ const FfiConverterTypeIngredientSource = (() => {
|
|
|
3553
3546
|
const inner = value.inner;
|
|
3554
3547
|
let size = 4;
|
|
3555
3548
|
size += FfiConverterTypeRangeSource.allocationSize(inner.source);
|
|
3556
|
-
size +=
|
|
3549
|
+
size += FfiConverterOptionalString.allocationSize(inner.format);
|
|
3550
|
+
size += FfiConverterSequenceString.allocationSize(inner.discoveredBy);
|
|
3557
3551
|
return size;
|
|
3558
3552
|
}
|
|
3559
3553
|
case "Descriptor": {
|
|
3560
3554
|
const inner = value.inner;
|
|
3561
3555
|
let size = 4;
|
|
3562
|
-
size +=
|
|
3556
|
+
size += FfiConverterString.allocationSize(inner.format);
|
|
3563
3557
|
return size;
|
|
3564
3558
|
}
|
|
3565
3559
|
default: throw new UniffiInternalError.UnexpectedEnumCase();
|
|
@@ -3572,7 +3566,7 @@ const FfiConverterTypeIngredientSource = (() => {
|
|
|
3572
3566
|
* Generated factory for {@link Thumbnail} record objects.
|
|
3573
3567
|
*/
|
|
3574
3568
|
const Thumbnail = (() => {
|
|
3575
|
-
const defaults = () => ({});
|
|
3569
|
+
const defaults = () => ({ format: void 0 });
|
|
3576
3570
|
const create = (() => {
|
|
3577
3571
|
return uniffiCreateRecord(defaults);
|
|
3578
3572
|
})();
|
|
@@ -3587,15 +3581,15 @@ const FfiConverterTypeThumbnail = (() => {
|
|
|
3587
3581
|
readFromCursor(c) {
|
|
3588
3582
|
return {
|
|
3589
3583
|
data: FfiConverterArrayBuffer.readFromCursor(c),
|
|
3590
|
-
format:
|
|
3584
|
+
format: FfiConverterOptionalString.readFromCursor(c)
|
|
3591
3585
|
};
|
|
3592
3586
|
}
|
|
3593
3587
|
writeIntoCursor(value, c) {
|
|
3594
3588
|
FfiConverterArrayBuffer.writeIntoCursor(value.data, c);
|
|
3595
|
-
|
|
3589
|
+
FfiConverterOptionalString.writeIntoCursor(value.format, c);
|
|
3596
3590
|
}
|
|
3597
3591
|
allocationSize(value) {
|
|
3598
|
-
return FfiConverterArrayBuffer.allocationSize(value.data) +
|
|
3592
|
+
return FfiConverterArrayBuffer.allocationSize(value.data) + FfiConverterOptionalString.allocationSize(value.format);
|
|
3599
3593
|
}
|
|
3600
3594
|
}
|
|
3601
3595
|
return new FFIConverter();
|
|
@@ -3621,20 +3615,18 @@ const FfiConverterTypeIngredient = (() => {
|
|
|
3621
3615
|
class FFIConverter extends AbstractFfiConverterByteArray {
|
|
3622
3616
|
readFromCursor(c) {
|
|
3623
3617
|
return {
|
|
3624
|
-
|
|
3618
|
+
kind: FfiConverterTypeIngredientKind.readFromCursor(c),
|
|
3625
3619
|
title: FfiConverterOptionalString.readFromCursor(c),
|
|
3626
|
-
thumbnail: FfiConverterOptionalTypeThumbnail.readFromCursor(c)
|
|
3627
|
-
discoveredBy: FfiConverterSequenceString.readFromCursor(c)
|
|
3620
|
+
thumbnail: FfiConverterOptionalTypeThumbnail.readFromCursor(c)
|
|
3628
3621
|
};
|
|
3629
3622
|
}
|
|
3630
3623
|
writeIntoCursor(value, c) {
|
|
3631
|
-
|
|
3624
|
+
FfiConverterTypeIngredientKind.writeIntoCursor(value.kind, c);
|
|
3632
3625
|
FfiConverterOptionalString.writeIntoCursor(value.title, c);
|
|
3633
3626
|
FfiConverterOptionalTypeThumbnail.writeIntoCursor(value.thumbnail, c);
|
|
3634
|
-
FfiConverterSequenceString.writeIntoCursor(value.discoveredBy, c);
|
|
3635
3627
|
}
|
|
3636
3628
|
allocationSize(value) {
|
|
3637
|
-
return
|
|
3629
|
+
return FfiConverterTypeIngredientKind.allocationSize(value.kind) + FfiConverterOptionalString.allocationSize(value.title) + FfiConverterOptionalTypeThumbnail.allocationSize(value.thumbnail);
|
|
3638
3630
|
}
|
|
3639
3631
|
}
|
|
3640
3632
|
return new FFIConverter();
|
|
@@ -3814,7 +3806,10 @@ const FfiConverterTypeJsonObject = FfiConverterString;
|
|
|
3814
3806
|
* Generated factory for {@link CustomAction} record objects.
|
|
3815
3807
|
*/
|
|
3816
3808
|
const CustomAction = (() => {
|
|
3817
|
-
const defaults = () => ({
|
|
3809
|
+
const defaults = () => ({
|
|
3810
|
+
detail: void 0,
|
|
3811
|
+
componentIds: []
|
|
3812
|
+
});
|
|
3818
3813
|
const create = (() => {
|
|
3819
3814
|
return uniffiCreateRecord(defaults);
|
|
3820
3815
|
})();
|
|
@@ -3829,27 +3824,27 @@ const FfiConverterTypeCustomAction = (() => {
|
|
|
3829
3824
|
readFromCursor(c) {
|
|
3830
3825
|
return {
|
|
3831
3826
|
label: FfiConverterString.readFromCursor(c),
|
|
3832
|
-
|
|
3827
|
+
parameters: FfiConverterTypeJsonObject.readFromCursor(c),
|
|
3833
3828
|
detail: FfiConverterOptionalTypeActionDetail.readFromCursor(c),
|
|
3834
3829
|
componentIds: FfiConverterSequenceString.readFromCursor(c)
|
|
3835
3830
|
};
|
|
3836
3831
|
}
|
|
3837
3832
|
writeIntoCursor(value, c) {
|
|
3838
3833
|
FfiConverterString.writeIntoCursor(value.label, c);
|
|
3839
|
-
FfiConverterTypeJsonObject.writeIntoCursor(value.
|
|
3834
|
+
FfiConverterTypeJsonObject.writeIntoCursor(value.parameters, c);
|
|
3840
3835
|
FfiConverterOptionalTypeActionDetail.writeIntoCursor(value.detail, c);
|
|
3841
3836
|
FfiConverterSequenceString.writeIntoCursor(value.componentIds, c);
|
|
3842
3837
|
}
|
|
3843
3838
|
allocationSize(value) {
|
|
3844
|
-
return FfiConverterString.allocationSize(value.label) + FfiConverterTypeJsonObject.allocationSize(value.
|
|
3839
|
+
return FfiConverterString.allocationSize(value.label) + FfiConverterTypeJsonObject.allocationSize(value.parameters) + FfiConverterOptionalTypeActionDetail.allocationSize(value.detail) + FfiConverterSequenceString.allocationSize(value.componentIds);
|
|
3845
3840
|
}
|
|
3846
3841
|
}
|
|
3847
3842
|
return new FFIConverter();
|
|
3848
3843
|
})();
|
|
3849
3844
|
/**
|
|
3850
|
-
* Generated factory for {@link
|
|
3845
|
+
* Generated factory for {@link Timespan} record objects.
|
|
3851
3846
|
*/
|
|
3852
|
-
const
|
|
3847
|
+
const Timespan = (() => {
|
|
3853
3848
|
const defaults = () => ({});
|
|
3854
3849
|
const create = (() => {
|
|
3855
3850
|
return uniffiCreateRecord(defaults);
|
|
@@ -3860,28 +3855,120 @@ const SoftBinding = (() => {
|
|
|
3860
3855
|
defaults: () => Object.freeze(defaults())
|
|
3861
3856
|
});
|
|
3862
3857
|
})();
|
|
3863
|
-
const
|
|
3858
|
+
const FfiConverterTypeTimespan = (() => {
|
|
3864
3859
|
class FFIConverter extends AbstractFfiConverterByteArray {
|
|
3865
3860
|
readFromCursor(c) {
|
|
3866
3861
|
return {
|
|
3867
|
-
|
|
3868
|
-
|
|
3862
|
+
start: FfiConverterDuration.readFromCursor(c),
|
|
3863
|
+
duration: FfiConverterDuration.readFromCursor(c)
|
|
3869
3864
|
};
|
|
3870
3865
|
}
|
|
3871
3866
|
writeIntoCursor(value, c) {
|
|
3872
|
-
|
|
3873
|
-
|
|
3867
|
+
FfiConverterDuration.writeIntoCursor(value.start, c);
|
|
3868
|
+
FfiConverterDuration.writeIntoCursor(value.duration, c);
|
|
3874
3869
|
}
|
|
3875
3870
|
allocationSize(value) {
|
|
3876
|
-
return
|
|
3871
|
+
return FfiConverterDuration.allocationSize(value.start) + FfiConverterDuration.allocationSize(value.duration);
|
|
3877
3872
|
}
|
|
3878
3873
|
}
|
|
3879
3874
|
return new FFIConverter();
|
|
3880
3875
|
})();
|
|
3881
|
-
|
|
3882
|
-
|
|
3883
|
-
|
|
3884
|
-
|
|
3876
|
+
/**
|
|
3877
|
+
* Generated factory for {@link Scope} record objects.
|
|
3878
|
+
*/
|
|
3879
|
+
const Scope = (() => {
|
|
3880
|
+
const defaults = () => ({ timespan: void 0 });
|
|
3881
|
+
const create = (() => {
|
|
3882
|
+
return uniffiCreateRecord(defaults);
|
|
3883
|
+
})();
|
|
3884
|
+
return Object.freeze({
|
|
3885
|
+
create,
|
|
3886
|
+
new: create,
|
|
3887
|
+
defaults: () => Object.freeze(defaults())
|
|
3888
|
+
});
|
|
3889
|
+
})();
|
|
3890
|
+
const FfiConverterTypeScope = (() => {
|
|
3891
|
+
class FFIConverter extends AbstractFfiConverterByteArray {
|
|
3892
|
+
readFromCursor(c) {
|
|
3893
|
+
return { timespan: FfiConverterOptionalTypeTimespan.readFromCursor(c) };
|
|
3894
|
+
}
|
|
3895
|
+
writeIntoCursor(value, c) {
|
|
3896
|
+
FfiConverterOptionalTypeTimespan.writeIntoCursor(value.timespan, c);
|
|
3897
|
+
}
|
|
3898
|
+
allocationSize(value) {
|
|
3899
|
+
return FfiConverterOptionalTypeTimespan.allocationSize(value.timespan);
|
|
3900
|
+
}
|
|
3901
|
+
}
|
|
3902
|
+
return new FFIConverter();
|
|
3903
|
+
})();
|
|
3904
|
+
/**
|
|
3905
|
+
* Generated factory for {@link Block} record objects.
|
|
3906
|
+
*/
|
|
3907
|
+
const Block = (() => {
|
|
3908
|
+
const defaults = () => ({ scope: Scope.create({}) });
|
|
3909
|
+
const create = (() => {
|
|
3910
|
+
return uniffiCreateRecord(defaults);
|
|
3911
|
+
})();
|
|
3912
|
+
return Object.freeze({
|
|
3913
|
+
create,
|
|
3914
|
+
new: create,
|
|
3915
|
+
defaults: () => Object.freeze(defaults())
|
|
3916
|
+
});
|
|
3917
|
+
})();
|
|
3918
|
+
const FfiConverterTypeBlock = (() => {
|
|
3919
|
+
class FFIConverter extends AbstractFfiConverterByteArray {
|
|
3920
|
+
readFromCursor(c) {
|
|
3921
|
+
return {
|
|
3922
|
+
value: FfiConverterArrayBuffer.readFromCursor(c),
|
|
3923
|
+
scope: FfiConverterTypeScope.readFromCursor(c)
|
|
3924
|
+
};
|
|
3925
|
+
}
|
|
3926
|
+
writeIntoCursor(value, c) {
|
|
3927
|
+
FfiConverterArrayBuffer.writeIntoCursor(value.value, c);
|
|
3928
|
+
FfiConverterTypeScope.writeIntoCursor(value.scope, c);
|
|
3929
|
+
}
|
|
3930
|
+
allocationSize(value) {
|
|
3931
|
+
return FfiConverterArrayBuffer.allocationSize(value.value) + FfiConverterTypeScope.allocationSize(value.scope);
|
|
3932
|
+
}
|
|
3933
|
+
}
|
|
3934
|
+
return new FFIConverter();
|
|
3935
|
+
})();
|
|
3936
|
+
/**
|
|
3937
|
+
* Generated factory for {@link SoftBinding} record objects.
|
|
3938
|
+
*/
|
|
3939
|
+
const SoftBinding = (() => {
|
|
3940
|
+
const defaults = () => ({});
|
|
3941
|
+
const create = (() => {
|
|
3942
|
+
return uniffiCreateRecord(defaults);
|
|
3943
|
+
})();
|
|
3944
|
+
return Object.freeze({
|
|
3945
|
+
create,
|
|
3946
|
+
new: create,
|
|
3947
|
+
defaults: () => Object.freeze(defaults())
|
|
3948
|
+
});
|
|
3949
|
+
})();
|
|
3950
|
+
const FfiConverterTypeSoftBinding = (() => {
|
|
3951
|
+
class FFIConverter extends AbstractFfiConverterByteArray {
|
|
3952
|
+
readFromCursor(c) {
|
|
3953
|
+
return {
|
|
3954
|
+
alg: FfiConverterString.readFromCursor(c),
|
|
3955
|
+
blocks: FfiConverterSequenceTypeBlock.readFromCursor(c)
|
|
3956
|
+
};
|
|
3957
|
+
}
|
|
3958
|
+
writeIntoCursor(value, c) {
|
|
3959
|
+
FfiConverterString.writeIntoCursor(value.alg, c);
|
|
3960
|
+
FfiConverterSequenceTypeBlock.writeIntoCursor(value.blocks, c);
|
|
3961
|
+
}
|
|
3962
|
+
allocationSize(value) {
|
|
3963
|
+
return FfiConverterString.allocationSize(value.alg) + FfiConverterSequenceTypeBlock.allocationSize(value.blocks);
|
|
3964
|
+
}
|
|
3965
|
+
}
|
|
3966
|
+
return new FFIConverter();
|
|
3967
|
+
})();
|
|
3968
|
+
let ActionKind_Tags = /* @__PURE__ */ function(ActionKind_Tags) {
|
|
3969
|
+
ActionKind_Tags["AddedText"] = "AddedText";
|
|
3970
|
+
ActionKind_Tags["AdjustedColor"] = "AdjustedColor";
|
|
3971
|
+
ActionKind_Tags["ChangedSpeed"] = "ChangedSpeed";
|
|
3885
3972
|
ActionKind_Tags["Converted"] = "Converted";
|
|
3886
3973
|
ActionKind_Tags["Cropped"] = "Cropped";
|
|
3887
3974
|
ActionKind_Tags["Deleted"] = "Deleted";
|
|
@@ -3901,14 +3988,13 @@ let ActionKind_Tags = /* @__PURE__ */ function(ActionKind_Tags) {
|
|
|
3901
3988
|
ActionKind_Tags["ResizedProportional"] = "ResizedProportional";
|
|
3902
3989
|
ActionKind_Tags["Transcoded"] = "Transcoded";
|
|
3903
3990
|
ActionKind_Tags["Trimmed"] = "Trimmed";
|
|
3904
|
-
ActionKind_Tags["Unknown"] = "Unknown";
|
|
3905
3991
|
ActionKind_Tags["WatermarkedBound"] = "WatermarkedBound";
|
|
3906
3992
|
ActionKind_Tags["WatermarkedUnbound"] = "WatermarkedUnbound";
|
|
3907
3993
|
return ActionKind_Tags;
|
|
3908
3994
|
}({});
|
|
3909
3995
|
/**
|
|
3910
|
-
* The C2PA 2.
|
|
3911
|
-
* Mirrored for the one variant that carries a binding, which crosses as the
|
|
3996
|
+
* The C2PA 2.4 workflow actions; see the core [`provenance::ActionKind`] for what each is.
|
|
3997
|
+
* Mirrored for the one variant that carries a binding, which crosses as the FFI record.
|
|
3912
3998
|
*/
|
|
3913
3999
|
const ActionKind = (() => {
|
|
3914
4000
|
class AddedText_ extends UniffiEnum {
|
|
@@ -4285,23 +4371,6 @@ const ActionKind = (() => {
|
|
|
4285
4371
|
return obj.tag === "Trimmed";
|
|
4286
4372
|
}
|
|
4287
4373
|
}
|
|
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
|
-
}
|
|
4305
4374
|
class WatermarkedBound_ extends UniffiEnum {
|
|
4306
4375
|
/**
|
|
4307
4376
|
* @private
|
|
@@ -4365,7 +4434,6 @@ const ActionKind = (() => {
|
|
|
4365
4434
|
ResizedProportional: ResizedProportional_,
|
|
4366
4435
|
Transcoded: Transcoded_,
|
|
4367
4436
|
Trimmed: Trimmed_,
|
|
4368
|
-
Unknown: Unknown_,
|
|
4369
4437
|
WatermarkedBound: WatermarkedBound_,
|
|
4370
4438
|
WatermarkedUnbound: WatermarkedUnbound_
|
|
4371
4439
|
});
|
|
@@ -4396,9 +4464,8 @@ const FfiConverterTypeActionKind = (() => {
|
|
|
4396
4464
|
case 20: return new ActionKind.ResizedProportional();
|
|
4397
4465
|
case 21: return new ActionKind.Transcoded();
|
|
4398
4466
|
case 22: return new ActionKind.Trimmed();
|
|
4399
|
-
case 23: return new ActionKind.
|
|
4400
|
-
case 24: return new ActionKind.
|
|
4401
|
-
case 25: return new ActionKind.WatermarkedUnbound();
|
|
4467
|
+
case 23: return new ActionKind.WatermarkedBound({ binding: FfiConverterTypeSoftBinding.readFromCursor(c) });
|
|
4468
|
+
case 24: return new ActionKind.WatermarkedUnbound();
|
|
4402
4469
|
default: throw new UniffiInternalError.UnexpectedEnumCase();
|
|
4403
4470
|
}
|
|
4404
4471
|
}
|
|
@@ -4470,17 +4537,14 @@ const FfiConverterTypeActionKind = (() => {
|
|
|
4470
4537
|
case "Trimmed":
|
|
4471
4538
|
c.writeI32(22);
|
|
4472
4539
|
return;
|
|
4473
|
-
case "Unknown":
|
|
4474
|
-
c.writeI32(23);
|
|
4475
|
-
return;
|
|
4476
4540
|
case "WatermarkedBound": {
|
|
4477
|
-
c.writeI32(
|
|
4541
|
+
c.writeI32(23);
|
|
4478
4542
|
const inner = value.inner;
|
|
4479
4543
|
FfiConverterTypeSoftBinding.writeIntoCursor(inner.binding, c);
|
|
4480
4544
|
return;
|
|
4481
4545
|
}
|
|
4482
4546
|
case "WatermarkedUnbound":
|
|
4483
|
-
c.writeI32(
|
|
4547
|
+
c.writeI32(24);
|
|
4484
4548
|
return;
|
|
4485
4549
|
default: throw new UniffiInternalError.UnexpectedEnumCase();
|
|
4486
4550
|
}
|
|
@@ -4509,7 +4573,6 @@ const FfiConverterTypeActionKind = (() => {
|
|
|
4509
4573
|
case "ResizedProportional": return 4;
|
|
4510
4574
|
case "Transcoded": return 4;
|
|
4511
4575
|
case "Trimmed": return 4;
|
|
4512
|
-
case "Unknown": return 4;
|
|
4513
4576
|
case "WatermarkedBound": {
|
|
4514
4577
|
const inner = value.inner;
|
|
4515
4578
|
let size = 4;
|
|
@@ -4527,7 +4590,11 @@ const FfiConverterTypeActionKind = (() => {
|
|
|
4527
4590
|
* Generated factory for {@link StandardAction} record objects.
|
|
4528
4591
|
*/
|
|
4529
4592
|
const StandardAction = (() => {
|
|
4530
|
-
const defaults = () => ({
|
|
4593
|
+
const defaults = () => ({
|
|
4594
|
+
parameters: "{}",
|
|
4595
|
+
detail: void 0,
|
|
4596
|
+
componentIds: []
|
|
4597
|
+
});
|
|
4531
4598
|
const create = (() => {
|
|
4532
4599
|
return uniffiCreateRecord(defaults);
|
|
4533
4600
|
})();
|
|
@@ -4542,17 +4609,19 @@ const FfiConverterTypeStandardAction = (() => {
|
|
|
4542
4609
|
readFromCursor(c) {
|
|
4543
4610
|
return {
|
|
4544
4611
|
kind: FfiConverterTypeActionKind.readFromCursor(c),
|
|
4612
|
+
parameters: FfiConverterTypeJsonObject.readFromCursor(c),
|
|
4545
4613
|
detail: FfiConverterOptionalTypeActionDetail.readFromCursor(c),
|
|
4546
4614
|
componentIds: FfiConverterSequenceString.readFromCursor(c)
|
|
4547
4615
|
};
|
|
4548
4616
|
}
|
|
4549
4617
|
writeIntoCursor(value, c) {
|
|
4550
4618
|
FfiConverterTypeActionKind.writeIntoCursor(value.kind, c);
|
|
4619
|
+
FfiConverterTypeJsonObject.writeIntoCursor(value.parameters, c);
|
|
4551
4620
|
FfiConverterOptionalTypeActionDetail.writeIntoCursor(value.detail, c);
|
|
4552
4621
|
FfiConverterSequenceString.writeIntoCursor(value.componentIds, c);
|
|
4553
4622
|
}
|
|
4554
4623
|
allocationSize(value) {
|
|
4555
|
-
return FfiConverterTypeActionKind.allocationSize(value.kind) + FfiConverterOptionalTypeActionDetail.allocationSize(value.detail) + FfiConverterSequenceString.allocationSize(value.componentIds);
|
|
4624
|
+
return FfiConverterTypeActionKind.allocationSize(value.kind) + FfiConverterTypeJsonObject.allocationSize(value.parameters) + FfiConverterOptionalTypeActionDetail.allocationSize(value.detail) + FfiConverterSequenceString.allocationSize(value.componentIds);
|
|
4556
4625
|
}
|
|
4557
4626
|
}
|
|
4558
4627
|
return new FFIConverter();
|
|
@@ -4660,7 +4729,7 @@ const FfiConverterTypeAction = (() => {
|
|
|
4660
4729
|
* Generated factory for {@link Identity} record objects.
|
|
4661
4730
|
*/
|
|
4662
4731
|
const Identity = (() => {
|
|
4663
|
-
const defaults = () => ({});
|
|
4732
|
+
const defaults = () => ({ roles: [] });
|
|
4664
4733
|
const create = (() => {
|
|
4665
4734
|
return uniffiCreateRecord(defaults);
|
|
4666
4735
|
})();
|
|
@@ -4723,6 +4792,9 @@ const ComponentEvent = (() => {
|
|
|
4723
4792
|
return obj.tag === "Placed";
|
|
4724
4793
|
}
|
|
4725
4794
|
}
|
|
4795
|
+
/**
|
|
4796
|
+
* `label` names the ingredient assertion the parent's active manifest holds for it.
|
|
4797
|
+
*/
|
|
4726
4798
|
class Removed_ extends UniffiEnum {
|
|
4727
4799
|
/**
|
|
4728
4800
|
* @private
|
|
@@ -4776,7 +4848,10 @@ const FfiConverterTypeComponentEvent = (() => {
|
|
|
4776
4848
|
readFromCursor(c) {
|
|
4777
4849
|
switch (c.readI32()) {
|
|
4778
4850
|
case 1: return new ComponentEvent.Placed({ detail: FfiConverterOptionalTypeActionDetail.readFromCursor(c) });
|
|
4779
|
-
case 2: return new ComponentEvent.Removed({
|
|
4851
|
+
case 2: return new ComponentEvent.Removed({
|
|
4852
|
+
label: FfiConverterString.readFromCursor(c),
|
|
4853
|
+
detail: FfiConverterOptionalTypeActionDetail.readFromCursor(c)
|
|
4854
|
+
});
|
|
4780
4855
|
case 3: return new ComponentEvent.InputTo();
|
|
4781
4856
|
default: throw new UniffiInternalError.UnexpectedEnumCase();
|
|
4782
4857
|
}
|
|
@@ -4792,6 +4867,7 @@ const FfiConverterTypeComponentEvent = (() => {
|
|
|
4792
4867
|
case "Removed": {
|
|
4793
4868
|
c.writeI32(2);
|
|
4794
4869
|
const inner = value.inner;
|
|
4870
|
+
FfiConverterString.writeIntoCursor(inner.label, c);
|
|
4795
4871
|
FfiConverterOptionalTypeActionDetail.writeIntoCursor(inner.detail, c);
|
|
4796
4872
|
return;
|
|
4797
4873
|
}
|
|
@@ -4812,6 +4888,7 @@ const FfiConverterTypeComponentEvent = (() => {
|
|
|
4812
4888
|
case "Removed": {
|
|
4813
4889
|
const inner = value.inner;
|
|
4814
4890
|
let size = 4;
|
|
4891
|
+
size += FfiConverterString.allocationSize(inner.label);
|
|
4815
4892
|
size += FfiConverterOptionalTypeActionDetail.allocationSize(inner.detail);
|
|
4816
4893
|
return size;
|
|
4817
4894
|
}
|
|
@@ -4840,18 +4917,16 @@ const FfiConverterTypeComponent = (() => {
|
|
|
4840
4917
|
class FFIConverter extends AbstractFfiConverterByteArray {
|
|
4841
4918
|
readFromCursor(c) {
|
|
4842
4919
|
return {
|
|
4843
|
-
id: FfiConverterString.readFromCursor(c),
|
|
4844
4920
|
asset: FfiConverterTypeIngredient.readFromCursor(c),
|
|
4845
4921
|
event: FfiConverterTypeComponentEvent.readFromCursor(c)
|
|
4846
4922
|
};
|
|
4847
4923
|
}
|
|
4848
4924
|
writeIntoCursor(value, c) {
|
|
4849
|
-
FfiConverterString.writeIntoCursor(value.id, c);
|
|
4850
4925
|
FfiConverterTypeIngredient.writeIntoCursor(value.asset, c);
|
|
4851
4926
|
FfiConverterTypeComponentEvent.writeIntoCursor(value.event, c);
|
|
4852
4927
|
}
|
|
4853
4928
|
allocationSize(value) {
|
|
4854
|
-
return
|
|
4929
|
+
return FfiConverterTypeIngredient.allocationSize(value.asset) + FfiConverterTypeComponentEvent.allocationSize(value.event);
|
|
4855
4930
|
}
|
|
4856
4931
|
}
|
|
4857
4932
|
return new FFIConverter();
|
|
@@ -4862,7 +4937,10 @@ const FfiConverterTypeComponent = (() => {
|
|
|
4862
4937
|
const AssetManifestSpec = (() => {
|
|
4863
4938
|
const defaults = () => ({
|
|
4864
4939
|
title: void 0,
|
|
4865
|
-
|
|
4940
|
+
actions: [],
|
|
4941
|
+
identity: void 0,
|
|
4942
|
+
assertions: [],
|
|
4943
|
+
components: /* @__PURE__ */ new Map()
|
|
4866
4944
|
});
|
|
4867
4945
|
const create = (() => {
|
|
4868
4946
|
return uniffiCreateRecord(defaults);
|
|
@@ -4882,7 +4960,7 @@ const FfiConverterTypeAssetManifestSpec = (() => {
|
|
|
4882
4960
|
actions: FfiConverterSequenceTypeAction.readFromCursor(c),
|
|
4883
4961
|
identity: FfiConverterOptionalTypeIdentity.readFromCursor(c),
|
|
4884
4962
|
assertions: FfiConverterSequenceTypeAssertion.readFromCursor(c),
|
|
4885
|
-
components:
|
|
4963
|
+
components: FfiConverterMapStringTypeComponent.readFromCursor(c)
|
|
4886
4964
|
};
|
|
4887
4965
|
}
|
|
4888
4966
|
writeIntoCursor(value, c) {
|
|
@@ -4891,19 +4969,19 @@ const FfiConverterTypeAssetManifestSpec = (() => {
|
|
|
4891
4969
|
FfiConverterSequenceTypeAction.writeIntoCursor(value.actions, c);
|
|
4892
4970
|
FfiConverterOptionalTypeIdentity.writeIntoCursor(value.identity, c);
|
|
4893
4971
|
FfiConverterSequenceTypeAssertion.writeIntoCursor(value.assertions, c);
|
|
4894
|
-
|
|
4972
|
+
FfiConverterMapStringTypeComponent.writeIntoCursor(value.components, c);
|
|
4895
4973
|
}
|
|
4896
4974
|
allocationSize(value) {
|
|
4897
|
-
return FfiConverterOptionalString.allocationSize(value.title) + FfiConverterTypeAssetOrigin.allocationSize(value.origin) + FfiConverterSequenceTypeAction.allocationSize(value.actions) + FfiConverterOptionalTypeIdentity.allocationSize(value.identity) + FfiConverterSequenceTypeAssertion.allocationSize(value.assertions) +
|
|
4975
|
+
return FfiConverterOptionalString.allocationSize(value.title) + FfiConverterTypeAssetOrigin.allocationSize(value.origin) + FfiConverterSequenceTypeAction.allocationSize(value.actions) + FfiConverterOptionalTypeIdentity.allocationSize(value.identity) + FfiConverterSequenceTypeAssertion.allocationSize(value.assertions) + FfiConverterMapStringTypeComponent.allocationSize(value.components);
|
|
4898
4976
|
}
|
|
4899
4977
|
}
|
|
4900
4978
|
return new FFIConverter();
|
|
4901
4979
|
})();
|
|
4902
4980
|
/**
|
|
4903
|
-
* Generated factory for {@link
|
|
4981
|
+
* Generated factory for {@link ByteRange} record objects.
|
|
4904
4982
|
*/
|
|
4905
|
-
const
|
|
4906
|
-
const defaults = () => ({
|
|
4983
|
+
const ByteRange = (() => {
|
|
4984
|
+
const defaults = () => ({});
|
|
4907
4985
|
const create = (() => {
|
|
4908
4986
|
return uniffiCreateRecord(defaults);
|
|
4909
4987
|
})();
|
|
@@ -4913,30 +4991,28 @@ const ConnectOptions = (() => {
|
|
|
4913
4991
|
defaults: () => Object.freeze(defaults())
|
|
4914
4992
|
});
|
|
4915
4993
|
})();
|
|
4916
|
-
const
|
|
4994
|
+
const FfiConverterTypeByteRange = (() => {
|
|
4917
4995
|
class FFIConverter extends AbstractFfiConverterByteArray {
|
|
4918
4996
|
readFromCursor(c) {
|
|
4919
4997
|
return {
|
|
4920
|
-
|
|
4921
|
-
|
|
4922
|
-
connectTimeoutMs: FfiConverterUInt32.readFromCursor(c)
|
|
4998
|
+
offset: FfiConverterUInt64.readFromCursor(c),
|
|
4999
|
+
length: FfiConverterUInt64.readFromCursor(c)
|
|
4923
5000
|
};
|
|
4924
5001
|
}
|
|
4925
5002
|
writeIntoCursor(value, c) {
|
|
4926
|
-
|
|
4927
|
-
|
|
4928
|
-
FfiConverterUInt32.writeIntoCursor(value.connectTimeoutMs, c);
|
|
5003
|
+
FfiConverterUInt64.writeIntoCursor(value.offset, c);
|
|
5004
|
+
FfiConverterUInt64.writeIntoCursor(value.length, c);
|
|
4929
5005
|
}
|
|
4930
5006
|
allocationSize(value) {
|
|
4931
|
-
return
|
|
5007
|
+
return FfiConverterUInt64.allocationSize(value.offset) + FfiConverterUInt64.allocationSize(value.length);
|
|
4932
5008
|
}
|
|
4933
5009
|
}
|
|
4934
5010
|
return new FFIConverter();
|
|
4935
5011
|
})();
|
|
4936
5012
|
/**
|
|
4937
|
-
* Generated factory for {@link
|
|
5013
|
+
* Generated factory for {@link ComputeRequest} record objects.
|
|
4938
5014
|
*/
|
|
4939
|
-
const
|
|
5015
|
+
const ComputeRequest = (() => {
|
|
4940
5016
|
const defaults = () => ({});
|
|
4941
5017
|
const create = (() => {
|
|
4942
5018
|
return uniffiCreateRecord(defaults);
|
|
@@ -4947,16 +5023,58 @@ const DeriveOptions = (() => {
|
|
|
4947
5023
|
defaults: () => Object.freeze(defaults())
|
|
4948
5024
|
});
|
|
4949
5025
|
})();
|
|
4950
|
-
const
|
|
5026
|
+
const FfiConverterTypeComputeRequest = (() => {
|
|
5027
|
+
class FFIConverter extends AbstractFfiConverterByteArray {
|
|
5028
|
+
readFromCursor(c) {
|
|
5029
|
+
return {
|
|
5030
|
+
source: FfiConverterTypeRangeSource.readFromCursor(c),
|
|
5031
|
+
format: FfiConverterString.readFromCursor(c)
|
|
5032
|
+
};
|
|
5033
|
+
}
|
|
5034
|
+
writeIntoCursor(value, c) {
|
|
5035
|
+
FfiConverterTypeRangeSource.writeIntoCursor(value.source, c);
|
|
5036
|
+
FfiConverterString.writeIntoCursor(value.format, c);
|
|
5037
|
+
}
|
|
5038
|
+
allocationSize(value) {
|
|
5039
|
+
return FfiConverterTypeRangeSource.allocationSize(value.source) + FfiConverterString.allocationSize(value.format);
|
|
5040
|
+
}
|
|
5041
|
+
}
|
|
5042
|
+
return new FFIConverter();
|
|
5043
|
+
})();
|
|
5044
|
+
/**
|
|
5045
|
+
* Generated factory for {@link ConnectOptions} record objects.
|
|
5046
|
+
*/
|
|
5047
|
+
const ConnectOptions = (() => {
|
|
5048
|
+
const defaults = () => ({
|
|
5049
|
+
headers: /* @__PURE__ */ new Map(),
|
|
5050
|
+
rpcTimeout: void 0,
|
|
5051
|
+
connectTimeout: void 0
|
|
5052
|
+
});
|
|
5053
|
+
const create = (() => {
|
|
5054
|
+
return uniffiCreateRecord(defaults);
|
|
5055
|
+
})();
|
|
5056
|
+
return Object.freeze({
|
|
5057
|
+
create,
|
|
5058
|
+
new: create,
|
|
5059
|
+
defaults: () => Object.freeze(defaults())
|
|
5060
|
+
});
|
|
5061
|
+
})();
|
|
5062
|
+
const FfiConverterTypeConnectOptions = (() => {
|
|
4951
5063
|
class FFIConverter extends AbstractFfiConverterByteArray {
|
|
4952
5064
|
readFromCursor(c) {
|
|
4953
|
-
return {
|
|
5065
|
+
return {
|
|
5066
|
+
headers: FfiConverterMapStringString.readFromCursor(c),
|
|
5067
|
+
rpcTimeout: FfiConverterOptionalDuration.readFromCursor(c),
|
|
5068
|
+
connectTimeout: FfiConverterOptionalDuration.readFromCursor(c)
|
|
5069
|
+
};
|
|
4954
5070
|
}
|
|
4955
5071
|
writeIntoCursor(value, c) {
|
|
4956
|
-
|
|
5072
|
+
FfiConverterMapStringString.writeIntoCursor(value.headers, c);
|
|
5073
|
+
FfiConverterOptionalDuration.writeIntoCursor(value.rpcTimeout, c);
|
|
5074
|
+
FfiConverterOptionalDuration.writeIntoCursor(value.connectTimeout, c);
|
|
4957
5075
|
}
|
|
4958
5076
|
allocationSize(value) {
|
|
4959
|
-
return
|
|
5077
|
+
return FfiConverterMapStringString.allocationSize(value.headers) + FfiConverterOptionalDuration.allocationSize(value.rpcTimeout) + FfiConverterOptionalDuration.allocationSize(value.connectTimeout);
|
|
4960
5078
|
}
|
|
4961
5079
|
}
|
|
4962
5080
|
return new FFIConverter();
|
|
@@ -4965,7 +5083,7 @@ const FfiConverterTypeDeriveOptions = (() => {
|
|
|
4965
5083
|
* Generated factory for {@link EmbedOptions} record objects.
|
|
4966
5084
|
*/
|
|
4967
5085
|
const EmbedOptions = (() => {
|
|
4968
|
-
const defaults = () => ({});
|
|
5086
|
+
const defaults = () => ({ format: void 0 });
|
|
4969
5087
|
const create = (() => {
|
|
4970
5088
|
return uniffiCreateRecord(defaults);
|
|
4971
5089
|
})();
|
|
@@ -4978,45 +5096,114 @@ const EmbedOptions = (() => {
|
|
|
4978
5096
|
const FfiConverterTypeEmbedOptions = (() => {
|
|
4979
5097
|
class FFIConverter extends AbstractFfiConverterByteArray {
|
|
4980
5098
|
readFromCursor(c) {
|
|
4981
|
-
return { format:
|
|
5099
|
+
return { format: FfiConverterOptionalString.readFromCursor(c) };
|
|
4982
5100
|
}
|
|
4983
5101
|
writeIntoCursor(value, c) {
|
|
4984
|
-
|
|
5102
|
+
FfiConverterOptionalString.writeIntoCursor(value.format, c);
|
|
4985
5103
|
}
|
|
4986
5104
|
allocationSize(value) {
|
|
4987
|
-
return
|
|
5105
|
+
return FfiConverterOptionalString.allocationSize(value.format);
|
|
4988
5106
|
}
|
|
4989
5107
|
}
|
|
4990
5108
|
return new FFIConverter();
|
|
4991
5109
|
})();
|
|
4992
5110
|
/**
|
|
4993
|
-
*
|
|
4994
|
-
*
|
|
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.
|
|
5111
|
+
* Where a stream's init manifest lives. The init segment always carries it, so there is no
|
|
5112
|
+
* remote-only delivery, and the segment comes back as bytes, so there is no output to name.
|
|
5002
5113
|
*/
|
|
5003
|
-
|
|
5004
|
-
[
|
|
5114
|
+
let StreamDelivery = /* @__PURE__ */ function(StreamDelivery) {
|
|
5115
|
+
StreamDelivery[StreamDelivery["Embedded"] = 0] = "Embedded";
|
|
5116
|
+
StreamDelivery[StreamDelivery["EmbeddedAndRemote"] = 1] = "EmbeddedAndRemote";
|
|
5117
|
+
return StreamDelivery;
|
|
5118
|
+
}({});
|
|
5119
|
+
const FfiConverterTypeStreamDelivery = (() => {
|
|
5120
|
+
class FFIConverter extends AbstractFfiConverterByteArray {
|
|
5121
|
+
readFromCursor(c) {
|
|
5122
|
+
switch (c.readI32()) {
|
|
5123
|
+
case 1: return 0;
|
|
5124
|
+
case 2: return 1;
|
|
5125
|
+
default: throw new UniffiInternalError.UnexpectedEnumCase();
|
|
5126
|
+
}
|
|
5127
|
+
}
|
|
5128
|
+
writeIntoCursor(value, c) {
|
|
5129
|
+
switch (value) {
|
|
5130
|
+
case 0: return c.writeI32(1);
|
|
5131
|
+
case 1: return c.writeI32(2);
|
|
5132
|
+
}
|
|
5133
|
+
}
|
|
5134
|
+
allocationSize(value) {
|
|
5135
|
+
return 4;
|
|
5136
|
+
}
|
|
5137
|
+
}
|
|
5138
|
+
return new FFIConverter();
|
|
5139
|
+
})();
|
|
5140
|
+
/**
|
|
5141
|
+
* Generated factory for {@link RotationPolicy} record objects.
|
|
5142
|
+
*/
|
|
5143
|
+
const RotationPolicy = (() => {
|
|
5144
|
+
const defaults = () => ({});
|
|
5145
|
+
const create = (() => {
|
|
5146
|
+
return uniffiCreateRecord(defaults);
|
|
5147
|
+
})();
|
|
5148
|
+
return Object.freeze({
|
|
5149
|
+
create,
|
|
5150
|
+
new: create,
|
|
5151
|
+
defaults: () => Object.freeze(defaults())
|
|
5152
|
+
});
|
|
5153
|
+
})();
|
|
5154
|
+
const FfiConverterTypeRotationPolicy = (() => {
|
|
5155
|
+
class FFIConverter extends AbstractFfiConverterByteArray {
|
|
5156
|
+
readFromCursor(c) {
|
|
5157
|
+
return {
|
|
5158
|
+
validityPeriod: FfiConverterDuration.readFromCursor(c),
|
|
5159
|
+
refreshPercent: FfiConverterUInt8.readFromCursor(c)
|
|
5160
|
+
};
|
|
5161
|
+
}
|
|
5162
|
+
writeIntoCursor(value, c) {
|
|
5163
|
+
FfiConverterDuration.writeIntoCursor(value.validityPeriod, c);
|
|
5164
|
+
FfiConverterUInt8.writeIntoCursor(value.refreshPercent, c);
|
|
5165
|
+
}
|
|
5166
|
+
allocationSize(value) {
|
|
5167
|
+
return FfiConverterDuration.allocationSize(value.validityPeriod) + FfiConverterUInt8.allocationSize(value.refreshPercent);
|
|
5168
|
+
}
|
|
5169
|
+
}
|
|
5170
|
+
return new FFIConverter();
|
|
5171
|
+
})();
|
|
5172
|
+
/**
|
|
5173
|
+
* Computes one soft-binding algorithm's values from an asset (a fingerprint calculated, a
|
|
5174
|
+
* watermark detected). `[]` is "no value here"; an error is "no trustworthy answer", so a failed
|
|
5175
|
+
* engine never reads as an unmarked asset.
|
|
5176
|
+
*/
|
|
5177
|
+
var ComputeImpl = class extends UniffiAbstractObject {
|
|
5178
|
+
[uniffiTypeNameSymbol] = "ComputeImpl";
|
|
5005
5179
|
[destructorGuardSymbol];
|
|
5006
5180
|
[pointerLiteralSymbol];
|
|
5007
5181
|
constructor(pointer) {
|
|
5008
5182
|
super();
|
|
5009
5183
|
this[pointerLiteralSymbol] = pointer;
|
|
5010
|
-
this[destructorGuardSymbol] =
|
|
5184
|
+
this[destructorGuardSymbol] = uniffiTypeComputeImplObjectFactory.bless(pointer);
|
|
5011
5185
|
}
|
|
5012
|
-
|
|
5186
|
+
/**
|
|
5187
|
+
* The C2PA soft-binding algorithm list label, e.g. `io.iscc.v0`.
|
|
5188
|
+
*/
|
|
5189
|
+
alg() {
|
|
5190
|
+
const __rb = uniffiCaller.rustCall((callStatus) => {
|
|
5191
|
+
return getter().uniffi_trylimbo_sdk_issuer_fn_method_compute_alg(uniffiTypeComputeImplObjectFactory.clonePointer(this), callStatus);
|
|
5192
|
+
}, FfiConverterString.lift.bind(FfiConverterString));
|
|
5193
|
+
try {
|
|
5194
|
+
return FfiConverterString.lift(__rb);
|
|
5195
|
+
} finally {
|
|
5196
|
+
getter().rustbuffer_free(__rb);
|
|
5197
|
+
}
|
|
5198
|
+
}
|
|
5199
|
+
async compute(request, asyncOpts_) {
|
|
5013
5200
|
const __stack = uniffiIsDebug ? (/* @__PURE__ */ new Error()).stack : void 0;
|
|
5014
5201
|
try {
|
|
5015
5202
|
return await uniffiRustCallAsync(uniffiCaller, () => {
|
|
5016
|
-
return getter().
|
|
5203
|
+
return getter().uniffi_trylimbo_sdk_issuer_fn_method_compute_compute(uniffiTypeComputeImplObjectFactory.clonePointer(this), FfiConverterTypeComputeRequest.lower(request, getter().rustbuffer_alloc));
|
|
5017
5204
|
}, 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) => {
|
|
5018
5205
|
try {
|
|
5019
|
-
return
|
|
5206
|
+
return FfiConverterSequenceTypeBlock.lift(__rb);
|
|
5020
5207
|
} finally {
|
|
5021
5208
|
getter().rustbuffer_free(__rb);
|
|
5022
5209
|
}
|
|
@@ -5029,26 +5216,26 @@ var BinderImpl = class extends UniffiAbstractObject {
|
|
|
5029
5216
|
uniffiDestroy() {
|
|
5030
5217
|
const ptr = this[destructorGuardSymbol];
|
|
5031
5218
|
if (ptr !== void 0) {
|
|
5032
|
-
const pointer =
|
|
5033
|
-
|
|
5034
|
-
|
|
5219
|
+
const pointer = uniffiTypeComputeImplObjectFactory.pointer(this);
|
|
5220
|
+
uniffiTypeComputeImplObjectFactory.freePointer(pointer);
|
|
5221
|
+
uniffiTypeComputeImplObjectFactory.unbless(ptr);
|
|
5035
5222
|
delete this[destructorGuardSymbol];
|
|
5036
5223
|
}
|
|
5037
5224
|
}
|
|
5038
5225
|
static instanceOf(obj_) {
|
|
5039
|
-
return
|
|
5226
|
+
return uniffiTypeComputeImplObjectFactory.isConcreteType(obj_);
|
|
5040
5227
|
}
|
|
5041
5228
|
};
|
|
5042
|
-
const
|
|
5229
|
+
const uniffiTypeComputeImplObjectFactory = (() => {
|
|
5043
5230
|
const registry = typeof FinalizationRegistry !== "undefined" ? new FinalizationRegistry((heldValue) => {
|
|
5044
|
-
|
|
5231
|
+
uniffiTypeComputeImplObjectFactory.freePointer(heldValue);
|
|
5045
5232
|
}) : null;
|
|
5046
5233
|
return {
|
|
5047
5234
|
create(pointer) {
|
|
5048
|
-
const instance = Object.create(
|
|
5235
|
+
const instance = Object.create(ComputeImpl.prototype);
|
|
5049
5236
|
instance[pointerLiteralSymbol] = pointer;
|
|
5050
5237
|
instance[destructorGuardSymbol] = this.bless(pointer);
|
|
5051
|
-
instance[uniffiTypeNameSymbol] = "
|
|
5238
|
+
instance[uniffiTypeNameSymbol] = "ComputeImpl";
|
|
5052
5239
|
return instance;
|
|
5053
5240
|
},
|
|
5054
5241
|
bless(p) {
|
|
@@ -5068,26 +5255,40 @@ const uniffiTypeBinderImplObjectFactory = (() => {
|
|
|
5068
5255
|
},
|
|
5069
5256
|
clonePointer(obj_) {
|
|
5070
5257
|
const pointer = this.pointer(obj_);
|
|
5071
|
-
return uniffiCaller.rustCall((callStatus) => getter().
|
|
5258
|
+
return uniffiCaller.rustCall((callStatus) => getter().uniffi_trylimbo_sdk_issuer_fn_clone_compute(pointer, callStatus), FfiConverterString.lift);
|
|
5072
5259
|
},
|
|
5073
5260
|
freePointer(pointer) {
|
|
5074
|
-
uniffiCaller.rustCall((callStatus) => getter().
|
|
5261
|
+
uniffiCaller.rustCall((callStatus) => getter().uniffi_trylimbo_sdk_issuer_fn_free_compute(pointer, callStatus), FfiConverterString.lift);
|
|
5075
5262
|
},
|
|
5076
5263
|
isConcreteType(obj_) {
|
|
5077
|
-
return obj_[destructorGuardSymbol] && obj_[uniffiTypeNameSymbol] === "
|
|
5264
|
+
return obj_[destructorGuardSymbol] && obj_[uniffiTypeNameSymbol] === "ComputeImpl";
|
|
5078
5265
|
}
|
|
5079
5266
|
};
|
|
5080
5267
|
})();
|
|
5081
|
-
const
|
|
5082
|
-
const
|
|
5268
|
+
const FfiConverterTypeCompute = new FfiConverterObjectWithCallbacks(uniffiTypeComputeImplObjectFactory);
|
|
5269
|
+
const uniffiCallbackInterfaceCompute = {
|
|
5083
5270
|
vtable: {
|
|
5084
|
-
|
|
5271
|
+
alg: (uniffiHandle) => {
|
|
5272
|
+
const uniffiMakeCall = () => {
|
|
5273
|
+
return FfiConverterTypeCompute.lift(uniffiHandle).alg();
|
|
5274
|
+
};
|
|
5275
|
+
const uniffiResult = UniffiResult.ready();
|
|
5276
|
+
const uniffiHandleSuccess = (obj) => {
|
|
5277
|
+
UniffiResult.writeSuccess(uniffiResult, FfiConverterString.lower(obj, getter().rustbuffer_alloc));
|
|
5278
|
+
};
|
|
5279
|
+
const uniffiHandleError = (code, errBuf) => {
|
|
5280
|
+
UniffiResult.writeError(uniffiResult, code, errBuf);
|
|
5281
|
+
};
|
|
5282
|
+
uniffiTraitInterfaceCall(uniffiMakeCall, uniffiHandleSuccess, uniffiHandleError, FfiConverterString.lower.bind(FfiConverterString), getter().rustbuffer_alloc);
|
|
5283
|
+
return uniffiResult;
|
|
5284
|
+
},
|
|
5285
|
+
compute: (uniffiHandle, request, uniffiFutureCallback, uniffiCallbackData) => {
|
|
5085
5286
|
const uniffiMakeCall = async (signal) => {
|
|
5086
|
-
return await
|
|
5287
|
+
return await FfiConverterTypeCompute.lift(uniffiHandle).compute(FfiConverterTypeComputeRequest.lift(request), { signal });
|
|
5087
5288
|
};
|
|
5088
5289
|
const uniffiHandleSuccess = (returnValue) => {
|
|
5089
5290
|
uniffiFutureCallback.call(uniffiFutureCallback, uniffiCallbackData, {
|
|
5090
|
-
return_value:
|
|
5291
|
+
return_value: FfiConverterSequenceTypeBlock.lower(returnValue, getter().rustbuffer_alloc),
|
|
5091
5292
|
call_status: uniffiCaller.createCallStatus()
|
|
5092
5293
|
});
|
|
5093
5294
|
};
|
|
@@ -5100,122 +5301,130 @@ const uniffiCallbackInterfaceBinder = {
|
|
|
5100
5301
|
return uniffiTraitInterfaceCallAsyncWithError(uniffiMakeCall, uniffiHandleSuccess, uniffiHandleError, SdkError.instanceOf, FfiConverterTypeSdkError.lower.bind(FfiConverterTypeSdkError), FfiConverterString.lower.bind(FfiConverterString), getter().rustbuffer_alloc);
|
|
5101
5302
|
},
|
|
5102
5303
|
uniffi_free: (uniffiHandle) => {
|
|
5103
|
-
|
|
5304
|
+
FfiConverterTypeCompute.drop(uniffiHandle);
|
|
5104
5305
|
},
|
|
5105
5306
|
uniffi_clone: (uniffiHandle) => {
|
|
5106
|
-
return
|
|
5307
|
+
return FfiConverterTypeCompute.clone(uniffiHandle);
|
|
5107
5308
|
}
|
|
5108
5309
|
},
|
|
5109
5310
|
register: () => {
|
|
5110
|
-
getter().
|
|
5311
|
+
getter().uniffi_trylimbo_sdk_issuer_fn_init_callback_vtable_compute(uniffiCallbackInterfaceCompute.vtable);
|
|
5111
5312
|
}
|
|
5112
5313
|
};
|
|
5113
|
-
let
|
|
5114
|
-
|
|
5115
|
-
|
|
5116
|
-
|
|
5117
|
-
return
|
|
5314
|
+
let SoftBindingSource_Tags = /* @__PURE__ */ function(SoftBindingSource_Tags) {
|
|
5315
|
+
SoftBindingSource_Tags["Builtin"] = "Builtin";
|
|
5316
|
+
SoftBindingSource_Tags["Held"] = "Held";
|
|
5317
|
+
SoftBindingSource_Tags["Custom"] = "Custom";
|
|
5318
|
+
return SoftBindingSource_Tags;
|
|
5118
5319
|
}({});
|
|
5119
5320
|
/**
|
|
5120
|
-
*
|
|
5121
|
-
* returns its signed init segment as bytes, so there is no output to name.
|
|
5321
|
+
* Where one assertion's values come from.
|
|
5122
5322
|
*/
|
|
5123
|
-
const
|
|
5124
|
-
|
|
5323
|
+
const SoftBindingSource = (() => {
|
|
5324
|
+
/**
|
|
5325
|
+
* This SDK's own engine for `alg`, run over the asset.
|
|
5326
|
+
*/
|
|
5327
|
+
class Builtin_ extends UniffiEnum {
|
|
5125
5328
|
/**
|
|
5126
5329
|
* @private
|
|
5127
5330
|
* This field is private and should not be used, use `tag` instead.
|
|
5128
5331
|
*/
|
|
5129
|
-
[uniffiTypeNameSymbol] = "
|
|
5130
|
-
tag = "
|
|
5332
|
+
[uniffiTypeNameSymbol] = "SoftBindingSource";
|
|
5333
|
+
tag = "Builtin";
|
|
5131
5334
|
inner;
|
|
5132
5335
|
constructor(inner) {
|
|
5133
|
-
super("
|
|
5336
|
+
super("SoftBindingSource", "Builtin");
|
|
5134
5337
|
this.inner = Object.freeze(inner);
|
|
5135
5338
|
}
|
|
5136
5339
|
static new(inner) {
|
|
5137
|
-
return new
|
|
5340
|
+
return new Builtin_(inner);
|
|
5138
5341
|
}
|
|
5139
5342
|
static instanceOf(obj) {
|
|
5140
|
-
return obj.tag === "
|
|
5343
|
+
return obj.tag === "Builtin";
|
|
5141
5344
|
}
|
|
5142
5345
|
}
|
|
5143
|
-
|
|
5346
|
+
/**
|
|
5347
|
+
* Values already held, declared as they are; nothing reads the asset for them.
|
|
5348
|
+
*/
|
|
5349
|
+
class Held_ extends UniffiEnum {
|
|
5144
5350
|
/**
|
|
5145
5351
|
* @private
|
|
5146
5352
|
* This field is private and should not be used, use `tag` instead.
|
|
5147
5353
|
*/
|
|
5148
|
-
[uniffiTypeNameSymbol] = "
|
|
5149
|
-
tag = "
|
|
5354
|
+
[uniffiTypeNameSymbol] = "SoftBindingSource";
|
|
5355
|
+
tag = "Held";
|
|
5150
5356
|
inner;
|
|
5151
5357
|
constructor(inner) {
|
|
5152
|
-
super("
|
|
5358
|
+
super("SoftBindingSource", "Held");
|
|
5153
5359
|
this.inner = Object.freeze(inner);
|
|
5154
5360
|
}
|
|
5155
5361
|
static new(inner) {
|
|
5156
|
-
return new
|
|
5362
|
+
return new Held_(inner);
|
|
5157
5363
|
}
|
|
5158
5364
|
static instanceOf(obj) {
|
|
5159
|
-
return obj.tag === "
|
|
5365
|
+
return obj.tag === "Held";
|
|
5160
5366
|
}
|
|
5161
5367
|
}
|
|
5162
|
-
|
|
5368
|
+
/**
|
|
5369
|
+
* Your engine, run over the asset.
|
|
5370
|
+
*/
|
|
5371
|
+
class Custom_ extends UniffiEnum {
|
|
5163
5372
|
/**
|
|
5164
5373
|
* @private
|
|
5165
5374
|
* This field is private and should not be used, use `tag` instead.
|
|
5166
5375
|
*/
|
|
5167
|
-
[uniffiTypeNameSymbol] = "
|
|
5168
|
-
tag = "
|
|
5376
|
+
[uniffiTypeNameSymbol] = "SoftBindingSource";
|
|
5377
|
+
tag = "Custom";
|
|
5169
5378
|
inner;
|
|
5170
5379
|
constructor(inner) {
|
|
5171
|
-
super("
|
|
5380
|
+
super("SoftBindingSource", "Custom");
|
|
5172
5381
|
this.inner = Object.freeze(inner);
|
|
5173
5382
|
}
|
|
5174
5383
|
static new(inner) {
|
|
5175
|
-
return new
|
|
5384
|
+
return new Custom_(inner);
|
|
5176
5385
|
}
|
|
5177
5386
|
static instanceOf(obj) {
|
|
5178
|
-
return obj.tag === "
|
|
5387
|
+
return obj.tag === "Custom";
|
|
5179
5388
|
}
|
|
5180
5389
|
}
|
|
5181
5390
|
function instanceOf(obj) {
|
|
5182
|
-
return obj[uniffiTypeNameSymbol] === "
|
|
5391
|
+
return obj[uniffiTypeNameSymbol] === "SoftBindingSource";
|
|
5183
5392
|
}
|
|
5184
5393
|
return Object.freeze({
|
|
5185
5394
|
instanceOf,
|
|
5186
|
-
|
|
5187
|
-
|
|
5188
|
-
|
|
5395
|
+
Builtin: Builtin_,
|
|
5396
|
+
Held: Held_,
|
|
5397
|
+
Custom: Custom_
|
|
5189
5398
|
});
|
|
5190
5399
|
})();
|
|
5191
|
-
const
|
|
5400
|
+
const FfiConverterTypeSoftBindingSource = (() => {
|
|
5192
5401
|
class FFIConverter extends AbstractFfiConverterByteArray {
|
|
5193
5402
|
readFromCursor(c) {
|
|
5194
5403
|
switch (c.readI32()) {
|
|
5195
|
-
case 1: return new
|
|
5196
|
-
case 2: return new
|
|
5197
|
-
case 3: return new
|
|
5404
|
+
case 1: return new SoftBindingSource.Builtin({ alg: FfiConverterString.readFromCursor(c) });
|
|
5405
|
+
case 2: return new SoftBindingSource.Held({ binding: FfiConverterTypeSoftBinding.readFromCursor(c) });
|
|
5406
|
+
case 3: return new SoftBindingSource.Custom({ compute: FfiConverterTypeCompute.readFromCursor(c) });
|
|
5198
5407
|
default: throw new UniffiInternalError.UnexpectedEnumCase();
|
|
5199
5408
|
}
|
|
5200
5409
|
}
|
|
5201
5410
|
writeIntoCursor(value, c) {
|
|
5202
5411
|
switch (value.tag) {
|
|
5203
|
-
case "
|
|
5412
|
+
case "Builtin": {
|
|
5204
5413
|
c.writeI32(1);
|
|
5205
5414
|
const inner = value.inner;
|
|
5206
|
-
|
|
5415
|
+
FfiConverterString.writeIntoCursor(inner.alg, c);
|
|
5207
5416
|
return;
|
|
5208
5417
|
}
|
|
5209
|
-
case "
|
|
5418
|
+
case "Held": {
|
|
5210
5419
|
c.writeI32(2);
|
|
5211
5420
|
const inner = value.inner;
|
|
5212
|
-
|
|
5421
|
+
FfiConverterTypeSoftBinding.writeIntoCursor(inner.binding, c);
|
|
5213
5422
|
return;
|
|
5214
5423
|
}
|
|
5215
|
-
case "
|
|
5424
|
+
case "Custom": {
|
|
5216
5425
|
c.writeI32(3);
|
|
5217
5426
|
const inner = value.inner;
|
|
5218
|
-
|
|
5427
|
+
FfiConverterTypeCompute.writeIntoCursor(inner.compute, c);
|
|
5219
5428
|
return;
|
|
5220
5429
|
}
|
|
5221
5430
|
default: throw new UniffiInternalError.UnexpectedEnumCase();
|
|
@@ -5223,22 +5432,22 @@ const FfiConverterTypeStreamDelivery = (() => {
|
|
|
5223
5432
|
}
|
|
5224
5433
|
allocationSize(value) {
|
|
5225
5434
|
switch (value.tag) {
|
|
5226
|
-
case "
|
|
5435
|
+
case "Builtin": {
|
|
5227
5436
|
const inner = value.inner;
|
|
5228
5437
|
let size = 4;
|
|
5229
|
-
size +=
|
|
5438
|
+
size += FfiConverterString.allocationSize(inner.alg);
|
|
5230
5439
|
return size;
|
|
5231
5440
|
}
|
|
5232
|
-
case "
|
|
5441
|
+
case "Held": {
|
|
5233
5442
|
const inner = value.inner;
|
|
5234
5443
|
let size = 4;
|
|
5235
|
-
size +=
|
|
5444
|
+
size += FfiConverterTypeSoftBinding.allocationSize(inner.binding);
|
|
5236
5445
|
return size;
|
|
5237
5446
|
}
|
|
5238
|
-
case "
|
|
5447
|
+
case "Custom": {
|
|
5239
5448
|
const inner = value.inner;
|
|
5240
5449
|
let size = 4;
|
|
5241
|
-
size +=
|
|
5450
|
+
size += FfiConverterTypeCompute.allocationSize(inner.compute);
|
|
5242
5451
|
return size;
|
|
5243
5452
|
}
|
|
5244
5453
|
default: throw new UniffiInternalError.UnexpectedEnumCase();
|
|
@@ -5248,42 +5457,10 @@ const FfiConverterTypeStreamDelivery = (() => {
|
|
|
5248
5457
|
return new FFIConverter();
|
|
5249
5458
|
})();
|
|
5250
5459
|
/**
|
|
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
|
-
/**
|
|
5283
5460
|
* Generated factory for {@link InitOptions} record objects.
|
|
5284
5461
|
*/
|
|
5285
5462
|
const InitOptions = (() => {
|
|
5286
|
-
const defaults = () => ({});
|
|
5463
|
+
const defaults = () => ({ softBindings: [] });
|
|
5287
5464
|
const create = (() => {
|
|
5288
5465
|
return uniffiCreateRecord(defaults);
|
|
5289
5466
|
})();
|
|
@@ -5298,15 +5475,17 @@ const FfiConverterTypeInitOptions = (() => {
|
|
|
5298
5475
|
readFromCursor(c) {
|
|
5299
5476
|
return {
|
|
5300
5477
|
delivery: FfiConverterTypeStreamDelivery.readFromCursor(c),
|
|
5301
|
-
rotationPolicy: FfiConverterTypeRotationPolicy.readFromCursor(c)
|
|
5478
|
+
rotationPolicy: FfiConverterTypeRotationPolicy.readFromCursor(c),
|
|
5479
|
+
softBindings: FfiConverterSequenceTypeSoftBindingSource.readFromCursor(c)
|
|
5302
5480
|
};
|
|
5303
5481
|
}
|
|
5304
5482
|
writeIntoCursor(value, c) {
|
|
5305
5483
|
FfiConverterTypeStreamDelivery.writeIntoCursor(value.delivery, c);
|
|
5306
5484
|
FfiConverterTypeRotationPolicy.writeIntoCursor(value.rotationPolicy, c);
|
|
5485
|
+
FfiConverterSequenceTypeSoftBindingSource.writeIntoCursor(value.softBindings, c);
|
|
5307
5486
|
}
|
|
5308
5487
|
allocationSize(value) {
|
|
5309
|
-
return FfiConverterTypeStreamDelivery.allocationSize(value.delivery) + FfiConverterTypeRotationPolicy.allocationSize(value.rotationPolicy);
|
|
5488
|
+
return FfiConverterTypeStreamDelivery.allocationSize(value.delivery) + FfiConverterTypeRotationPolicy.allocationSize(value.rotationPolicy) + FfiConverterSequenceTypeSoftBindingSource.allocationSize(value.softBindings);
|
|
5310
5489
|
}
|
|
5311
5490
|
}
|
|
5312
5491
|
return new FFIConverter();
|
|
@@ -5329,16 +5508,16 @@ const FfiConverterTypeInitOutcome = (() => {
|
|
|
5329
5508
|
class FFIConverter extends AbstractFfiConverterByteArray {
|
|
5330
5509
|
readFromCursor(c) {
|
|
5331
5510
|
return {
|
|
5332
|
-
|
|
5333
|
-
|
|
5511
|
+
bytes: FfiConverterArrayBuffer.readFromCursor(c),
|
|
5512
|
+
validUntil: FfiConverterTimestamp.readFromCursor(c)
|
|
5334
5513
|
};
|
|
5335
5514
|
}
|
|
5336
5515
|
writeIntoCursor(value, c) {
|
|
5337
|
-
FfiConverterArrayBuffer.writeIntoCursor(value.
|
|
5338
|
-
|
|
5516
|
+
FfiConverterArrayBuffer.writeIntoCursor(value.bytes, c);
|
|
5517
|
+
FfiConverterTimestamp.writeIntoCursor(value.validUntil, c);
|
|
5339
5518
|
}
|
|
5340
5519
|
allocationSize(value) {
|
|
5341
|
-
return FfiConverterArrayBuffer.allocationSize(value.
|
|
5520
|
+
return FfiConverterArrayBuffer.allocationSize(value.bytes) + FfiConverterTimestamp.allocationSize(value.validUntil);
|
|
5342
5521
|
}
|
|
5343
5522
|
}
|
|
5344
5523
|
return new FFIConverter();
|
|
@@ -5347,7 +5526,10 @@ const FfiConverterTypeInitOutcome = (() => {
|
|
|
5347
5526
|
* Generated factory for {@link MarkOptions} record objects.
|
|
5348
5527
|
*/
|
|
5349
5528
|
const MarkOptions = (() => {
|
|
5350
|
-
const defaults = () => ({
|
|
5529
|
+
const defaults = () => ({
|
|
5530
|
+
format: void 0,
|
|
5531
|
+
algorithms: []
|
|
5532
|
+
});
|
|
5351
5533
|
const create = (() => {
|
|
5352
5534
|
return uniffiCreateRecord(defaults);
|
|
5353
5535
|
})();
|
|
@@ -5361,18 +5543,16 @@ const FfiConverterTypeMarkOptions = (() => {
|
|
|
5361
5543
|
class FFIConverter extends AbstractFfiConverterByteArray {
|
|
5362
5544
|
readFromCursor(c) {
|
|
5363
5545
|
return {
|
|
5364
|
-
format:
|
|
5365
|
-
|
|
5366
|
-
signpost: FfiConverterBool.readFromCursor(c)
|
|
5546
|
+
format: FfiConverterOptionalString.readFromCursor(c),
|
|
5547
|
+
algorithms: FfiConverterSequenceString.readFromCursor(c)
|
|
5367
5548
|
};
|
|
5368
5549
|
}
|
|
5369
5550
|
writeIntoCursor(value, c) {
|
|
5370
|
-
|
|
5371
|
-
|
|
5372
|
-
FfiConverterBool.writeIntoCursor(value.signpost, c);
|
|
5551
|
+
FfiConverterOptionalString.writeIntoCursor(value.format, c);
|
|
5552
|
+
FfiConverterSequenceString.writeIntoCursor(value.algorithms, c);
|
|
5373
5553
|
}
|
|
5374
5554
|
allocationSize(value) {
|
|
5375
|
-
return
|
|
5555
|
+
return FfiConverterOptionalString.allocationSize(value.format) + FfiConverterSequenceString.allocationSize(value.algorithms);
|
|
5376
5556
|
}
|
|
5377
5557
|
}
|
|
5378
5558
|
return new FFIConverter();
|
|
@@ -5395,28 +5575,24 @@ const FfiConverterTypeMarkOutcome = (() => {
|
|
|
5395
5575
|
class FFIConverter extends AbstractFfiConverterByteArray {
|
|
5396
5576
|
readFromCursor(c) {
|
|
5397
5577
|
return {
|
|
5398
|
-
bytes: FfiConverterArrayBuffer.readFromCursor(c),
|
|
5399
5578
|
format: FfiConverterString.readFromCursor(c),
|
|
5400
|
-
fileName: FfiConverterString.readFromCursor(c),
|
|
5401
5579
|
actions: FfiConverterSequenceTypeAction.readFromCursor(c)
|
|
5402
5580
|
};
|
|
5403
5581
|
}
|
|
5404
5582
|
writeIntoCursor(value, c) {
|
|
5405
|
-
FfiConverterArrayBuffer.writeIntoCursor(value.bytes, c);
|
|
5406
5583
|
FfiConverterString.writeIntoCursor(value.format, c);
|
|
5407
|
-
FfiConverterString.writeIntoCursor(value.fileName, c);
|
|
5408
5584
|
FfiConverterSequenceTypeAction.writeIntoCursor(value.actions, c);
|
|
5409
5585
|
}
|
|
5410
5586
|
allocationSize(value) {
|
|
5411
|
-
return
|
|
5587
|
+
return FfiConverterString.allocationSize(value.format) + FfiConverterSequenceTypeAction.allocationSize(value.actions);
|
|
5412
5588
|
}
|
|
5413
5589
|
}
|
|
5414
5590
|
return new FFIConverter();
|
|
5415
5591
|
})();
|
|
5416
5592
|
/**
|
|
5417
|
-
* Generated factory for {@link
|
|
5593
|
+
* Generated factory for {@link MintRequest} record objects.
|
|
5418
5594
|
*/
|
|
5419
|
-
const
|
|
5595
|
+
const MintRequest = (() => {
|
|
5420
5596
|
const defaults = () => ({});
|
|
5421
5597
|
const create = (() => {
|
|
5422
5598
|
return uniffiCreateRecord(defaults);
|
|
@@ -5427,20 +5603,16 @@ const Region = (() => {
|
|
|
5427
5603
|
defaults: () => Object.freeze(defaults())
|
|
5428
5604
|
});
|
|
5429
5605
|
})();
|
|
5430
|
-
const
|
|
5606
|
+
const FfiConverterTypeMintRequest = (() => {
|
|
5431
5607
|
class FFIConverter extends AbstractFfiConverterByteArray {
|
|
5432
5608
|
readFromCursor(c) {
|
|
5433
|
-
return {
|
|
5434
|
-
offset: FfiConverterUInt64.readFromCursor(c),
|
|
5435
|
-
length: FfiConverterUInt64.readFromCursor(c)
|
|
5436
|
-
};
|
|
5609
|
+
return { validityPeriod: FfiConverterDuration.readFromCursor(c) };
|
|
5437
5610
|
}
|
|
5438
5611
|
writeIntoCursor(value, c) {
|
|
5439
|
-
|
|
5440
|
-
FfiConverterUInt64.writeIntoCursor(value.length, c);
|
|
5612
|
+
FfiConverterDuration.writeIntoCursor(value.validityPeriod, c);
|
|
5441
5613
|
}
|
|
5442
5614
|
allocationSize(value) {
|
|
5443
|
-
return
|
|
5615
|
+
return FfiConverterDuration.allocationSize(value.validityPeriod);
|
|
5444
5616
|
}
|
|
5445
5617
|
}
|
|
5446
5618
|
return new FFIConverter();
|
|
@@ -5465,16 +5637,48 @@ const FfiConverterTypeSegmentOutcome = (() => {
|
|
|
5465
5637
|
return {
|
|
5466
5638
|
bytes: FfiConverterArrayBuffer.readFromCursor(c),
|
|
5467
5639
|
rotationDue: FfiConverterBool.readFromCursor(c),
|
|
5468
|
-
|
|
5640
|
+
validUntil: FfiConverterTimestamp.readFromCursor(c)
|
|
5469
5641
|
};
|
|
5470
5642
|
}
|
|
5471
5643
|
writeIntoCursor(value, c) {
|
|
5472
5644
|
FfiConverterArrayBuffer.writeIntoCursor(value.bytes, c);
|
|
5473
5645
|
FfiConverterBool.writeIntoCursor(value.rotationDue, c);
|
|
5474
|
-
|
|
5646
|
+
FfiConverterTimestamp.writeIntoCursor(value.validUntil, c);
|
|
5475
5647
|
}
|
|
5476
5648
|
allocationSize(value) {
|
|
5477
|
-
return FfiConverterArrayBuffer.allocationSize(value.bytes) + FfiConverterBool.allocationSize(value.rotationDue) +
|
|
5649
|
+
return FfiConverterArrayBuffer.allocationSize(value.bytes) + FfiConverterBool.allocationSize(value.rotationDue) + FfiConverterTimestamp.allocationSize(value.validUntil);
|
|
5650
|
+
}
|
|
5651
|
+
}
|
|
5652
|
+
return new FFIConverter();
|
|
5653
|
+
})();
|
|
5654
|
+
/**
|
|
5655
|
+
* Generated factory for {@link SessionKey} record objects.
|
|
5656
|
+
*/
|
|
5657
|
+
const SessionKey = (() => {
|
|
5658
|
+
const defaults = () => ({});
|
|
5659
|
+
const create = (() => {
|
|
5660
|
+
return uniffiCreateRecord(defaults);
|
|
5661
|
+
})();
|
|
5662
|
+
return Object.freeze({
|
|
5663
|
+
create,
|
|
5664
|
+
new: create,
|
|
5665
|
+
defaults: () => Object.freeze(defaults())
|
|
5666
|
+
});
|
|
5667
|
+
})();
|
|
5668
|
+
const FfiConverterTypeSessionKey = (() => {
|
|
5669
|
+
class FFIConverter extends AbstractFfiConverterByteArray {
|
|
5670
|
+
readFromCursor(c) {
|
|
5671
|
+
return {
|
|
5672
|
+
kid: FfiConverterArrayBuffer.readFromCursor(c),
|
|
5673
|
+
publicKey: FfiConverterArrayBuffer.readFromCursor(c)
|
|
5674
|
+
};
|
|
5675
|
+
}
|
|
5676
|
+
writeIntoCursor(value, c) {
|
|
5677
|
+
FfiConverterArrayBuffer.writeIntoCursor(value.kid, c);
|
|
5678
|
+
FfiConverterArrayBuffer.writeIntoCursor(value.publicKey, c);
|
|
5679
|
+
}
|
|
5680
|
+
allocationSize(value) {
|
|
5681
|
+
return FfiConverterArrayBuffer.allocationSize(value.kid) + FfiConverterArrayBuffer.allocationSize(value.publicKey);
|
|
5478
5682
|
}
|
|
5479
5683
|
}
|
|
5480
5684
|
return new FFIConverter();
|
|
@@ -5681,10 +5885,9 @@ let SignOutput_Tags = /* @__PURE__ */ function(SignOutput_Tags) {
|
|
|
5681
5885
|
return SignOutput_Tags;
|
|
5682
5886
|
}({});
|
|
5683
5887
|
/**
|
|
5684
|
-
* What a `sign` hands back beyond the sidecar it always returns: the sidecar alone, or the
|
|
5685
|
-
* signed asset written
|
|
5686
|
-
* [`SignOutput`](
|
|
5687
|
-
* storage means.
|
|
5888
|
+
* What a `sign` hands back beyond the sidecar it always returns: the sidecar alone, or the whole
|
|
5889
|
+
* signed asset written into `into` in the same call, replacing what it held. See the core
|
|
5890
|
+
* [`SignOutput`](core::SignOutput) for what pointing `into` at the asset's own storage means.
|
|
5688
5891
|
*/
|
|
5689
5892
|
const SignOutput = (() => {
|
|
5690
5893
|
class Sidecar_ extends UniffiEnum {
|
|
@@ -5773,16 +5976,15 @@ const FfiConverterTypeSignOutput = (() => {
|
|
|
5773
5976
|
let AssetDelivery_Tags = /* @__PURE__ */ function(AssetDelivery_Tags) {
|
|
5774
5977
|
AssetDelivery_Tags["Embedded"] = "Embedded";
|
|
5775
5978
|
AssetDelivery_Tags["Remote"] = "Remote";
|
|
5776
|
-
AssetDelivery_Tags["
|
|
5979
|
+
AssetDelivery_Tags["EmbeddedAndRemote"] = "EmbeddedAndRemote";
|
|
5777
5980
|
return AssetDelivery_Tags;
|
|
5778
5981
|
}({});
|
|
5779
5982
|
/**
|
|
5780
|
-
*
|
|
5983
|
+
* Where a static asset's manifest lives and, when it is in the asset, what comes back.
|
|
5781
5984
|
*
|
|
5782
|
-
* Embedded manifests
|
|
5783
|
-
*
|
|
5784
|
-
*
|
|
5785
|
-
* through its embedded manifest and permits an empty strategy list.
|
|
5985
|
+
* Embedded manifests are not indexed, so a watermark on one is refused: it could never lead back
|
|
5986
|
+
* to the manifest. Remote needs a soft binding the deployment resolves and never touches the
|
|
5987
|
+
* asset, so it names no output.
|
|
5786
5988
|
*/
|
|
5787
5989
|
const AssetDelivery = (() => {
|
|
5788
5990
|
class Embedded_ extends UniffiEnum {
|
|
@@ -5811,35 +6013,33 @@ const AssetDelivery = (() => {
|
|
|
5811
6013
|
*/
|
|
5812
6014
|
[uniffiTypeNameSymbol] = "AssetDelivery";
|
|
5813
6015
|
tag = "Remote";
|
|
5814
|
-
|
|
5815
|
-
constructor(inner) {
|
|
6016
|
+
constructor() {
|
|
5816
6017
|
super("AssetDelivery", "Remote");
|
|
5817
|
-
this.inner = Object.freeze(inner);
|
|
5818
6018
|
}
|
|
5819
|
-
static new(
|
|
5820
|
-
return new Remote_(
|
|
6019
|
+
static new() {
|
|
6020
|
+
return new Remote_();
|
|
5821
6021
|
}
|
|
5822
6022
|
static instanceOf(obj) {
|
|
5823
6023
|
return obj.tag === "Remote";
|
|
5824
6024
|
}
|
|
5825
6025
|
}
|
|
5826
|
-
class
|
|
6026
|
+
class EmbeddedAndRemote_ extends UniffiEnum {
|
|
5827
6027
|
/**
|
|
5828
6028
|
* @private
|
|
5829
6029
|
* This field is private and should not be used, use `tag` instead.
|
|
5830
6030
|
*/
|
|
5831
6031
|
[uniffiTypeNameSymbol] = "AssetDelivery";
|
|
5832
|
-
tag = "
|
|
6032
|
+
tag = "EmbeddedAndRemote";
|
|
5833
6033
|
inner;
|
|
5834
6034
|
constructor(inner) {
|
|
5835
|
-
super("AssetDelivery", "
|
|
6035
|
+
super("AssetDelivery", "EmbeddedAndRemote");
|
|
5836
6036
|
this.inner = Object.freeze(inner);
|
|
5837
6037
|
}
|
|
5838
6038
|
static new(inner) {
|
|
5839
|
-
return new
|
|
6039
|
+
return new EmbeddedAndRemote_(inner);
|
|
5840
6040
|
}
|
|
5841
6041
|
static instanceOf(obj) {
|
|
5842
|
-
return obj.tag === "
|
|
6042
|
+
return obj.tag === "EmbeddedAndRemote";
|
|
5843
6043
|
}
|
|
5844
6044
|
}
|
|
5845
6045
|
function instanceOf(obj) {
|
|
@@ -5849,22 +6049,16 @@ const AssetDelivery = (() => {
|
|
|
5849
6049
|
instanceOf,
|
|
5850
6050
|
Embedded: Embedded_,
|
|
5851
6051
|
Remote: Remote_,
|
|
5852
|
-
|
|
6052
|
+
EmbeddedAndRemote: EmbeddedAndRemote_
|
|
5853
6053
|
});
|
|
5854
6054
|
})();
|
|
5855
6055
|
const FfiConverterTypeAssetDelivery = (() => {
|
|
5856
6056
|
class FFIConverter extends AbstractFfiConverterByteArray {
|
|
5857
6057
|
readFromCursor(c) {
|
|
5858
6058
|
switch (c.readI32()) {
|
|
5859
|
-
case 1: return new AssetDelivery.Embedded({
|
|
5860
|
-
|
|
5861
|
-
|
|
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
|
-
});
|
|
6059
|
+
case 1: return new AssetDelivery.Embedded({ output: FfiConverterTypeSignOutput.readFromCursor(c) });
|
|
6060
|
+
case 2: return new AssetDelivery.Remote();
|
|
6061
|
+
case 3: return new AssetDelivery.EmbeddedAndRemote({ output: FfiConverterTypeSignOutput.readFromCursor(c) });
|
|
5868
6062
|
default: throw new UniffiInternalError.UnexpectedEnumCase();
|
|
5869
6063
|
}
|
|
5870
6064
|
}
|
|
@@ -5873,20 +6067,15 @@ const FfiConverterTypeAssetDelivery = (() => {
|
|
|
5873
6067
|
case "Embedded": {
|
|
5874
6068
|
c.writeI32(1);
|
|
5875
6069
|
const inner = value.inner;
|
|
5876
|
-
FfiConverterSequenceTypeBinder.writeIntoCursor(inner.binders, c);
|
|
5877
6070
|
FfiConverterTypeSignOutput.writeIntoCursor(inner.output, c);
|
|
5878
6071
|
return;
|
|
5879
6072
|
}
|
|
5880
|
-
case "Remote":
|
|
6073
|
+
case "Remote":
|
|
5881
6074
|
c.writeI32(2);
|
|
5882
|
-
const inner = value.inner;
|
|
5883
|
-
FfiConverterSequenceTypeBinder.writeIntoCursor(inner.binders, c);
|
|
5884
6075
|
return;
|
|
5885
|
-
|
|
5886
|
-
case "Both": {
|
|
6076
|
+
case "EmbeddedAndRemote": {
|
|
5887
6077
|
c.writeI32(3);
|
|
5888
6078
|
const inner = value.inner;
|
|
5889
|
-
FfiConverterSequenceTypeBinder.writeIntoCursor(inner.binders, c);
|
|
5890
6079
|
FfiConverterTypeSignOutput.writeIntoCursor(inner.output, c);
|
|
5891
6080
|
return;
|
|
5892
6081
|
}
|
|
@@ -5898,20 +6087,13 @@ const FfiConverterTypeAssetDelivery = (() => {
|
|
|
5898
6087
|
case "Embedded": {
|
|
5899
6088
|
const inner = value.inner;
|
|
5900
6089
|
let size = 4;
|
|
5901
|
-
size += FfiConverterSequenceTypeBinder.allocationSize(inner.binders);
|
|
5902
6090
|
size += FfiConverterTypeSignOutput.allocationSize(inner.output);
|
|
5903
6091
|
return size;
|
|
5904
6092
|
}
|
|
5905
|
-
case "Remote":
|
|
5906
|
-
|
|
5907
|
-
let size = 4;
|
|
5908
|
-
size += FfiConverterSequenceTypeBinder.allocationSize(inner.binders);
|
|
5909
|
-
return size;
|
|
5910
|
-
}
|
|
5911
|
-
case "Both": {
|
|
6093
|
+
case "Remote": return 4;
|
|
6094
|
+
case "EmbeddedAndRemote": {
|
|
5912
6095
|
const inner = value.inner;
|
|
5913
6096
|
let size = 4;
|
|
5914
|
-
size += FfiConverterSequenceTypeBinder.allocationSize(inner.binders);
|
|
5915
6097
|
size += FfiConverterTypeSignOutput.allocationSize(inner.output);
|
|
5916
6098
|
return size;
|
|
5917
6099
|
}
|
|
@@ -5925,7 +6107,11 @@ const FfiConverterTypeAssetDelivery = (() => {
|
|
|
5925
6107
|
* Generated factory for {@link SignOptions} record objects.
|
|
5926
6108
|
*/
|
|
5927
6109
|
const SignOptions = (() => {
|
|
5928
|
-
const defaults = () => ({
|
|
6110
|
+
const defaults = () => ({
|
|
6111
|
+
format: void 0,
|
|
6112
|
+
thumbnail: void 0,
|
|
6113
|
+
softBindings: []
|
|
6114
|
+
});
|
|
5929
6115
|
const create = (() => {
|
|
5930
6116
|
return uniffiCreateRecord(defaults);
|
|
5931
6117
|
})();
|
|
@@ -5940,17 +6126,19 @@ const FfiConverterTypeSignOptions = (() => {
|
|
|
5940
6126
|
readFromCursor(c) {
|
|
5941
6127
|
return {
|
|
5942
6128
|
delivery: FfiConverterTypeAssetDelivery.readFromCursor(c),
|
|
5943
|
-
format:
|
|
5944
|
-
thumbnail: FfiConverterOptionalTypeThumbnail.readFromCursor(c)
|
|
6129
|
+
format: FfiConverterOptionalString.readFromCursor(c),
|
|
6130
|
+
thumbnail: FfiConverterOptionalTypeThumbnail.readFromCursor(c),
|
|
6131
|
+
softBindings: FfiConverterSequenceTypeSoftBindingSource.readFromCursor(c)
|
|
5945
6132
|
};
|
|
5946
6133
|
}
|
|
5947
6134
|
writeIntoCursor(value, c) {
|
|
5948
6135
|
FfiConverterTypeAssetDelivery.writeIntoCursor(value.delivery, c);
|
|
5949
|
-
|
|
6136
|
+
FfiConverterOptionalString.writeIntoCursor(value.format, c);
|
|
5950
6137
|
FfiConverterOptionalTypeThumbnail.writeIntoCursor(value.thumbnail, c);
|
|
6138
|
+
FfiConverterSequenceTypeSoftBindingSource.writeIntoCursor(value.softBindings, c);
|
|
5951
6139
|
}
|
|
5952
6140
|
allocationSize(value) {
|
|
5953
|
-
return FfiConverterTypeAssetDelivery.allocationSize(value.delivery) +
|
|
6141
|
+
return FfiConverterTypeAssetDelivery.allocationSize(value.delivery) + FfiConverterOptionalString.allocationSize(value.format) + FfiConverterOptionalTypeThumbnail.allocationSize(value.thumbnail) + FfiConverterSequenceTypeSoftBindingSource.allocationSize(value.softBindings);
|
|
5954
6142
|
}
|
|
5955
6143
|
}
|
|
5956
6144
|
return new FFIConverter();
|
|
@@ -5987,25 +6175,25 @@ const FfiConverterTypeSignOutcome = (() => {
|
|
|
5987
6175
|
}
|
|
5988
6176
|
return new FFIConverter();
|
|
5989
6177
|
})();
|
|
5990
|
-
let
|
|
5991
|
-
|
|
5992
|
-
|
|
5993
|
-
return
|
|
6178
|
+
let StreamOrigin_Tags = /* @__PURE__ */ function(StreamOrigin_Tags) {
|
|
6179
|
+
StreamOrigin_Tags["Created"] = "Created";
|
|
6180
|
+
StreamOrigin_Tags["Opened"] = "Opened";
|
|
6181
|
+
return StreamOrigin_Tags;
|
|
5994
6182
|
}({});
|
|
5995
6183
|
/**
|
|
5996
|
-
* An origin a
|
|
6184
|
+
* An origin a stream states; see the core [`provenance::StreamOrigin`].
|
|
5997
6185
|
*/
|
|
5998
|
-
const
|
|
6186
|
+
const StreamOrigin = (() => {
|
|
5999
6187
|
class Created_ extends UniffiEnum {
|
|
6000
6188
|
/**
|
|
6001
6189
|
* @private
|
|
6002
6190
|
* This field is private and should not be used, use `tag` instead.
|
|
6003
6191
|
*/
|
|
6004
|
-
[uniffiTypeNameSymbol] = "
|
|
6192
|
+
[uniffiTypeNameSymbol] = "StreamOrigin";
|
|
6005
6193
|
tag = "Created";
|
|
6006
6194
|
inner;
|
|
6007
6195
|
constructor(v0) {
|
|
6008
|
-
super("
|
|
6196
|
+
super("StreamOrigin", "Created");
|
|
6009
6197
|
this.inner = Object.freeze([v0]);
|
|
6010
6198
|
}
|
|
6011
6199
|
static new(v0) {
|
|
@@ -6020,11 +6208,11 @@ const Origin = (() => {
|
|
|
6020
6208
|
* @private
|
|
6021
6209
|
* This field is private and should not be used, use `tag` instead.
|
|
6022
6210
|
*/
|
|
6023
|
-
[uniffiTypeNameSymbol] = "
|
|
6211
|
+
[uniffiTypeNameSymbol] = "StreamOrigin";
|
|
6024
6212
|
tag = "Opened";
|
|
6025
6213
|
inner;
|
|
6026
6214
|
constructor(v0) {
|
|
6027
|
-
super("
|
|
6215
|
+
super("StreamOrigin", "Opened");
|
|
6028
6216
|
this.inner = Object.freeze([v0]);
|
|
6029
6217
|
}
|
|
6030
6218
|
static new(v0) {
|
|
@@ -6035,7 +6223,7 @@ const Origin = (() => {
|
|
|
6035
6223
|
}
|
|
6036
6224
|
}
|
|
6037
6225
|
function instanceOf(obj) {
|
|
6038
|
-
return obj[uniffiTypeNameSymbol] === "
|
|
6226
|
+
return obj[uniffiTypeNameSymbol] === "StreamOrigin";
|
|
6039
6227
|
}
|
|
6040
6228
|
return Object.freeze({
|
|
6041
6229
|
instanceOf,
|
|
@@ -6043,12 +6231,12 @@ const Origin = (() => {
|
|
|
6043
6231
|
Opened: Opened_
|
|
6044
6232
|
});
|
|
6045
6233
|
})();
|
|
6046
|
-
const
|
|
6234
|
+
const FfiConverterTypeStreamOrigin = (() => {
|
|
6047
6235
|
class FFIConverter extends AbstractFfiConverterByteArray {
|
|
6048
6236
|
readFromCursor(c) {
|
|
6049
6237
|
switch (c.readI32()) {
|
|
6050
|
-
case 1: return new
|
|
6051
|
-
case 2: return new
|
|
6238
|
+
case 1: return new StreamOrigin.Created(FfiConverterTypeCreatedOrigin.readFromCursor(c));
|
|
6239
|
+
case 2: return new StreamOrigin.Opened(FfiConverterTypeOpenedOrigin.readFromCursor(c));
|
|
6052
6240
|
default: throw new UniffiInternalError.UnexpectedEnumCase();
|
|
6053
6241
|
}
|
|
6054
6242
|
}
|
|
@@ -6095,7 +6283,10 @@ const FfiConverterTypeOrigin = (() => {
|
|
|
6095
6283
|
const StreamManifestSpec = (() => {
|
|
6096
6284
|
const defaults = () => ({
|
|
6097
6285
|
title: void 0,
|
|
6098
|
-
|
|
6286
|
+
actions: [],
|
|
6287
|
+
identity: void 0,
|
|
6288
|
+
assertions: [],
|
|
6289
|
+
components: /* @__PURE__ */ new Map()
|
|
6099
6290
|
});
|
|
6100
6291
|
const create = (() => {
|
|
6101
6292
|
return uniffiCreateRecord(defaults);
|
|
@@ -6111,33 +6302,34 @@ const FfiConverterTypeStreamManifestSpec = (() => {
|
|
|
6111
6302
|
readFromCursor(c) {
|
|
6112
6303
|
return {
|
|
6113
6304
|
title: FfiConverterOptionalString.readFromCursor(c),
|
|
6114
|
-
origin:
|
|
6305
|
+
origin: FfiConverterTypeStreamOrigin.readFromCursor(c),
|
|
6115
6306
|
actions: FfiConverterSequenceTypeAction.readFromCursor(c),
|
|
6116
6307
|
identity: FfiConverterOptionalTypeIdentity.readFromCursor(c),
|
|
6117
6308
|
assertions: FfiConverterSequenceTypeAssertion.readFromCursor(c),
|
|
6118
|
-
components:
|
|
6309
|
+
components: FfiConverterMapStringTypeComponent.readFromCursor(c)
|
|
6119
6310
|
};
|
|
6120
6311
|
}
|
|
6121
6312
|
writeIntoCursor(value, c) {
|
|
6122
6313
|
FfiConverterOptionalString.writeIntoCursor(value.title, c);
|
|
6123
|
-
|
|
6314
|
+
FfiConverterTypeStreamOrigin.writeIntoCursor(value.origin, c);
|
|
6124
6315
|
FfiConverterSequenceTypeAction.writeIntoCursor(value.actions, c);
|
|
6125
6316
|
FfiConverterOptionalTypeIdentity.writeIntoCursor(value.identity, c);
|
|
6126
6317
|
FfiConverterSequenceTypeAssertion.writeIntoCursor(value.assertions, c);
|
|
6127
|
-
|
|
6318
|
+
FfiConverterMapStringTypeComponent.writeIntoCursor(value.components, c);
|
|
6128
6319
|
}
|
|
6129
6320
|
allocationSize(value) {
|
|
6130
|
-
return FfiConverterOptionalString.allocationSize(value.title) +
|
|
6321
|
+
return FfiConverterOptionalString.allocationSize(value.title) + FfiConverterTypeStreamOrigin.allocationSize(value.origin) + FfiConverterSequenceTypeAction.allocationSize(value.actions) + FfiConverterOptionalTypeIdentity.allocationSize(value.identity) + FfiConverterSequenceTypeAssertion.allocationSize(value.assertions) + FfiConverterMapStringTypeComponent.allocationSize(value.components);
|
|
6131
6322
|
}
|
|
6132
6323
|
}
|
|
6133
6324
|
return new FFIConverter();
|
|
6134
6325
|
})();
|
|
6135
6326
|
/**
|
|
6136
|
-
* One
|
|
6327
|
+
* One stream, from `init` to `stop` or `rotate`.
|
|
6137
6328
|
*
|
|
6138
|
-
* Carries the whole per-stream state, so it cannot be mistyped
|
|
6139
|
-
*
|
|
6140
|
-
*
|
|
6329
|
+
* Carries the whole per-stream state, so it cannot be mistyped or confused with another
|
|
6330
|
+
* stream's: every call after `init` goes through the handle that started it, and nothing about
|
|
6331
|
+
* the stream ever appears in a caller's argument list again. Once `stop` or a `rotate` succeeds
|
|
6332
|
+
* it refuses every call.
|
|
6141
6333
|
*/
|
|
6142
6334
|
var StreamSession = class extends UniffiAbstractObject {
|
|
6143
6335
|
[uniffiTypeNameSymbol] = "StreamSession";
|
|
@@ -6151,17 +6343,18 @@ var StreamSession = class extends UniffiAbstractObject {
|
|
|
6151
6343
|
/**
|
|
6152
6344
|
* Sign one media (moof) segment from a [`RangeSource`]. Does not touch the signer channel;
|
|
6153
6345
|
* works through a signer outage. `rotation_due` flips when the key validity threshold
|
|
6154
|
-
* passes;
|
|
6346
|
+
* passes; then call `StreamIssuer.rotate` with this session.
|
|
6155
6347
|
*
|
|
6156
6348
|
* # Errors
|
|
6157
6349
|
*
|
|
6158
|
-
* Fails on a vault error,
|
|
6350
|
+
* Fails on a vault error, a segment that isn't a BMFF media segment, or with
|
|
6351
|
+
* `FAILED_PRECONDITION` (`SESSION_ENDED`) after `stop` or a `rotate`.
|
|
6159
6352
|
*/
|
|
6160
|
-
async sign(
|
|
6353
|
+
async sign(source, asyncOpts_) {
|
|
6161
6354
|
const __stack = uniffiIsDebug ? (/* @__PURE__ */ new Error()).stack : void 0;
|
|
6162
6355
|
try {
|
|
6163
6356
|
return await uniffiRustCallAsync(uniffiCaller, () => {
|
|
6164
|
-
return getter().uniffi_trylimbo_sdk_issuer_fn_method_streamsession_sign(uniffiTypeStreamSessionObjectFactory.clonePointer(this), FfiConverterTypeRangeSource.lower(
|
|
6357
|
+
return getter().uniffi_trylimbo_sdk_issuer_fn_method_streamsession_sign(uniffiTypeStreamSessionObjectFactory.clonePointer(this), FfiConverterTypeRangeSource.lower(source, getter().rustbuffer_alloc));
|
|
6165
6358
|
}, 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) => {
|
|
6166
6359
|
try {
|
|
6167
6360
|
return FfiConverterTypeSegmentOutcome.lift(__rb);
|
|
@@ -6175,11 +6368,13 @@ var StreamSession = class extends UniffiAbstractObject {
|
|
|
6175
6368
|
}
|
|
6176
6369
|
}
|
|
6177
6370
|
/**
|
|
6178
|
-
* End the stream: forget its session key, so nothing can sign under it again.
|
|
6371
|
+
* End the stream: forget its session key, so nothing can sign under it again. Idempotent:
|
|
6372
|
+
* stopping an ended session succeeds. A failed stop can be retried.
|
|
6179
6373
|
*
|
|
6180
6374
|
* # Errors
|
|
6181
6375
|
*
|
|
6182
|
-
* Fails on a vault error
|
|
6376
|
+
* Fails on a vault error, or with `FAILED_PRECONDITION` (`SESSION_ENDED`) with another
|
|
6377
|
+
* `stop` or `rotate` in flight.
|
|
6183
6378
|
*/
|
|
6184
6379
|
async stop(asyncOpts_) {
|
|
6185
6380
|
const __stack = uniffiIsDebug ? (/* @__PURE__ */ new Error()).stack : void 0;
|
|
@@ -6278,40 +6473,8 @@ const FfiConverterTypeStreamStart = (() => {
|
|
|
6278
6473
|
return new FFIConverter();
|
|
6279
6474
|
})();
|
|
6280
6475
|
/**
|
|
6281
|
-
*
|
|
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.
|
|
6476
|
+
* Whether a fragmented-MP4 segment is the init (moov) or a media (moof) segment: whether it goes
|
|
6477
|
+
* to `StreamIssuer.init` or `StreamSession.sign`.
|
|
6315
6478
|
*/
|
|
6316
6479
|
let SegmentKind = /* @__PURE__ */ function(SegmentKind) {
|
|
6317
6480
|
SegmentKind[SegmentKind["Init"] = 0] = "Init";
|
|
@@ -6358,9 +6521,9 @@ const uniffiCallbackInterfacePluginAuthor = {
|
|
|
6358
6521
|
uniffiTraitInterfaceCallWithError(uniffiMakeCall, uniffiHandleSuccess, uniffiHandleError, SdkError.instanceOf, FfiConverterTypeSdkError.lower.bind(FfiConverterTypeSdkError), FfiConverterString.lower.bind(FfiConverterString), getter().rustbuffer_alloc);
|
|
6359
6522
|
return uniffiResult;
|
|
6360
6523
|
},
|
|
6361
|
-
sniff: (uniffiHandle,
|
|
6524
|
+
sniff: (uniffiHandle, source, uniffiFutureCallback, uniffiCallbackData) => {
|
|
6362
6525
|
const uniffiMakeCall = async (signal) => {
|
|
6363
|
-
return await FfiConverterTypePluginAuthor.lift(uniffiHandle).sniff(FfiConverterTypeRangeSource.lift(
|
|
6526
|
+
return await FfiConverterTypePluginAuthor.lift(uniffiHandle).sniff(FfiConverterTypeRangeSource.lift(source), { signal });
|
|
6364
6527
|
};
|
|
6365
6528
|
const uniffiHandleSuccess = (returnValue) => {
|
|
6366
6529
|
uniffiFutureCallback.call(uniffiFutureCallback, uniffiCallbackData, {
|
|
@@ -6376,13 +6539,13 @@ const uniffiCallbackInterfacePluginAuthor = {
|
|
|
6376
6539
|
};
|
|
6377
6540
|
return uniffiTraitInterfaceCallAsyncWithError(uniffiMakeCall, uniffiHandleSuccess, uniffiHandleError, SdkError.instanceOf, FfiConverterTypeSdkError.lower.bind(FfiConverterTypeSdkError), FfiConverterString.lower.bind(FfiConverterString), getter().rustbuffer_alloc);
|
|
6378
6541
|
},
|
|
6379
|
-
locate: (uniffiHandle,
|
|
6542
|
+
locate: (uniffiHandle, source, uniffiFutureCallback, uniffiCallbackData) => {
|
|
6380
6543
|
const uniffiMakeCall = async (signal) => {
|
|
6381
|
-
return await FfiConverterTypePluginAuthor.lift(uniffiHandle).locate(FfiConverterTypeRangeSource.lift(
|
|
6544
|
+
return await FfiConverterTypePluginAuthor.lift(uniffiHandle).locate(FfiConverterTypeRangeSource.lift(source), { signal });
|
|
6382
6545
|
};
|
|
6383
6546
|
const uniffiHandleSuccess = (returnValue) => {
|
|
6384
6547
|
uniffiFutureCallback.call(uniffiFutureCallback, uniffiCallbackData, {
|
|
6385
|
-
return_value:
|
|
6548
|
+
return_value: FfiConverterSequenceTypeByteRange.lower(returnValue, getter().rustbuffer_alloc),
|
|
6386
6549
|
call_status: uniffiCaller.createCallStatus()
|
|
6387
6550
|
});
|
|
6388
6551
|
};
|
|
@@ -6394,13 +6557,13 @@ const uniffiCallbackInterfacePluginAuthor = {
|
|
|
6394
6557
|
};
|
|
6395
6558
|
return uniffiTraitInterfaceCallAsyncWithError(uniffiMakeCall, uniffiHandleSuccess, uniffiHandleError, SdkError.instanceOf, FfiConverterTypeSdkError.lower.bind(FfiConverterTypeSdkError), FfiConverterString.lower.bind(FfiConverterString), getter().rustbuffer_alloc);
|
|
6396
6559
|
},
|
|
6397
|
-
reserve_slot: (uniffiHandle,
|
|
6560
|
+
reserve_slot: (uniffiHandle, sink, reserve, uniffiFutureCallback, uniffiCallbackData) => {
|
|
6398
6561
|
const uniffiMakeCall = async (signal) => {
|
|
6399
|
-
return await FfiConverterTypePluginAuthor.lift(uniffiHandle).reserveSlot(FfiConverterTypeRangeSink.lift(
|
|
6562
|
+
return await FfiConverterTypePluginAuthor.lift(uniffiHandle).reserveSlot(FfiConverterTypeRangeSink.lift(sink), FfiConverterUInt64.lift(reserve), { signal });
|
|
6400
6563
|
};
|
|
6401
6564
|
const uniffiHandleSuccess = (returnValue) => {
|
|
6402
6565
|
uniffiFutureCallback.call(uniffiFutureCallback, uniffiCallbackData, {
|
|
6403
|
-
return_value:
|
|
6566
|
+
return_value: FfiConverterSequenceTypeByteRange.lower(returnValue, getter().rustbuffer_alloc),
|
|
6404
6567
|
call_status: uniffiCaller.createCallStatus()
|
|
6405
6568
|
});
|
|
6406
6569
|
};
|
|
@@ -6446,18 +6609,16 @@ var AssetIssuer = class extends UniffiAbstractObject {
|
|
|
6446
6609
|
}, FfiConverterString.lift.bind(FfiConverterString)));
|
|
6447
6610
|
}
|
|
6448
6611
|
/**
|
|
6449
|
-
* Sign an asset from a [`RangeSource`], returning the sidecar
|
|
6450
|
-
* `
|
|
6451
|
-
*
|
|
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.
|
|
6612
|
+
* Sign an asset from a [`RangeSource`], returning the sidecar and the active manifest's id.
|
|
6613
|
+
* `options.delivery` says where the manifest lives and, through its output, where the signed
|
|
6614
|
+
* asset is written. `plugins` resolves a non-c2pa format (e.g. MXF); see the module docs.
|
|
6454
6615
|
*
|
|
6455
6616
|
* # Errors
|
|
6456
6617
|
*
|
|
6457
|
-
*
|
|
6458
|
-
*
|
|
6618
|
+
* A format that is no media type, that the bytes contradict or that neither names; an RPC,
|
|
6619
|
+
* hashing, authoring or protocol failure.
|
|
6459
6620
|
*/
|
|
6460
|
-
async sign(source, manifest, options, plugins, asyncOpts_) {
|
|
6621
|
+
async sign(source, manifest, options, plugins = [], asyncOpts_) {
|
|
6461
6622
|
const __stack = uniffiIsDebug ? (/* @__PURE__ */ new Error()).stack : void 0;
|
|
6462
6623
|
try {
|
|
6463
6624
|
return await uniffiRustCallAsync(uniffiCaller, () => {
|
|
@@ -6528,11 +6689,10 @@ const uniffiTypeAssetIssuerObjectFactory = (() => {
|
|
|
6528
6689
|
})();
|
|
6529
6690
|
const FfiConverterTypeAssetIssuer = new FfiConverterObject(uniffiTypeAssetIssuerObjectFactory);
|
|
6530
6691
|
/**
|
|
6531
|
-
*
|
|
6692
|
+
* Inserts invisible watermarks through the deployment's marking route.
|
|
6532
6693
|
*
|
|
6533
6694
|
* Separate from [`AssetIssuer`] because marking is a content edit, not a signing step: it
|
|
6534
|
-
*
|
|
6535
|
-
* rather than leaving anything downstream to infer them.
|
|
6695
|
+
* happens before signing, and it returns the actions it owes the manifest.
|
|
6536
6696
|
*/
|
|
6537
6697
|
var AssetMarker = class extends UniffiAbstractObject {
|
|
6538
6698
|
[uniffiTypeNameSymbol] = "AssetMarker";
|
|
@@ -6552,19 +6712,21 @@ var AssetMarker = class extends UniffiAbstractObject {
|
|
|
6552
6712
|
}, FfiConverterString.lift.bind(FfiConverterString)));
|
|
6553
6713
|
}
|
|
6554
6714
|
/**
|
|
6555
|
-
* Mark an
|
|
6556
|
-
*
|
|
6715
|
+
* Mark an asset from a [`RangeSource`], writing the marked asset into `into` in place of
|
|
6716
|
+
* what it held, and return one `c2pa.watermarked.*` action per mark, in the order inserted.
|
|
6717
|
+
* Sign what `into` holds.
|
|
6557
6718
|
*
|
|
6558
6719
|
* # Errors
|
|
6559
6720
|
*
|
|
6560
|
-
*
|
|
6561
|
-
*
|
|
6721
|
+
* An unlisted algorithm, a format that is no media type or that the bytes contradict, an
|
|
6722
|
+
* asset above the upload ceiling, a source or sink that fails, or a marking route that
|
|
6723
|
+
* refused or answered out of contract.
|
|
6562
6724
|
*/
|
|
6563
|
-
async mark(source, options, asyncOpts_) {
|
|
6725
|
+
async mark(source, into, options, asyncOpts_) {
|
|
6564
6726
|
const __stack = uniffiIsDebug ? (/* @__PURE__ */ new Error()).stack : void 0;
|
|
6565
6727
|
try {
|
|
6566
6728
|
return await uniffiRustCallAsync(uniffiCaller, () => {
|
|
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));
|
|
6729
|
+
return getter().uniffi_trylimbo_sdk_issuer_fn_method_assetmarker_mark(uniffiTypeAssetMarkerObjectFactory.clonePointer(this), FfiConverterTypeRangeSource.lower(source, getter().rustbuffer_alloc), FfiConverterTypeRangeSink.lower(into, getter().rustbuffer_alloc), FfiConverterTypeMarkOptions.lower(options, getter().rustbuffer_alloc));
|
|
6568
6730
|
}, 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) => {
|
|
6569
6731
|
try {
|
|
6570
6732
|
return FfiConverterTypeMarkOutcome.lift(__rb);
|
|
@@ -6642,10 +6804,6 @@ const FfiConverterTypeAssetMarker = new FfiConverterObject(uniffiTypeAssetMarker
|
|
|
6642
6804
|
* That is what makes [`MemorySink`]'s ceiling stop applying: there is no byte array to count in an
|
|
6643
6805
|
* `i32` and nothing resident, so a multi-GB master is signed at the disk's speed rather than the
|
|
6644
6806
|
* 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.
|
|
6649
6807
|
*/
|
|
6650
6808
|
var FileSink = class extends UniffiAbstractObject {
|
|
6651
6809
|
[uniffiTypeNameSymbol] = "FileSink";
|
|
@@ -6657,8 +6815,8 @@ var FileSink = class extends UniffiAbstractObject {
|
|
|
6657
6815
|
this[destructorGuardSymbol] = uniffiTypeFileSinkObjectFactory.bless(pointer);
|
|
6658
6816
|
}
|
|
6659
6817
|
/**
|
|
6660
|
-
* Create `path`, or truncate it if it is already there. What `
|
|
6661
|
-
*
|
|
6818
|
+
* Create `path`, or truncate it if it is already there. What a `sign` output wants: the
|
|
6819
|
+
* signed asset is written into it whole.
|
|
6662
6820
|
*
|
|
6663
6821
|
* # Errors
|
|
6664
6822
|
*
|
|
@@ -6670,9 +6828,9 @@ var FileSink = class extends UniffiAbstractObject {
|
|
|
6670
6828
|
}, FfiConverterString.lift.bind(FfiConverterString)));
|
|
6671
6829
|
}
|
|
6672
6830
|
/**
|
|
6673
|
-
* Open an existing `path` for reading and writing, keeping what is in it. What
|
|
6674
|
-
*
|
|
6675
|
-
*
|
|
6831
|
+
* Open an existing `path` for reading and writing, keeping what is in it. What `embed` wants:
|
|
6832
|
+
* the asset is already there and the manifest is written into it, so truncating it would
|
|
6833
|
+
* destroy the very thing being signed.
|
|
6676
6834
|
*
|
|
6677
6835
|
* # Errors
|
|
6678
6836
|
*
|
|
@@ -6905,188 +7063,8 @@ const uniffiTypeFileSourceObjectFactory = (() => {
|
|
|
6905
7063
|
})();
|
|
6906
7064
|
const FfiConverterTypeFileSource = new FfiConverterObject(uniffiTypeFileSourceObjectFactory);
|
|
6907
7065
|
/**
|
|
6908
|
-
*
|
|
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).
|
|
7066
|
+
* An in-memory [`RangeSink`] for a caller that wants `embed`'s composed result back:
|
|
7067
|
+
* `sink = MemorySink(data)`, pass it to `embed`, then read `sink.bytes()`.
|
|
7090
7068
|
*
|
|
7091
7069
|
* # Size ceiling
|
|
7092
7070
|
*
|
|
@@ -7098,9 +7076,14 @@ const FfiConverterTypeIsccBinder = new FfiConverterObject(uniffiTypeIsccBinderOb
|
|
|
7098
7076
|
* [`RangeSink`] over a file (or any store that seeks) for anything approaching that: the SDK
|
|
7099
7077
|
* writes ranges straight through it and never holds the asset.
|
|
7100
7078
|
*
|
|
7101
|
-
* Construction and `bytes()` each
|
|
7102
|
-
*
|
|
7103
|
-
*
|
|
7079
|
+
* Construction and `bytes()` each move the whole asset across the boundary once, on the calling
|
|
7080
|
+
* thread. A ranged sink pays neither.
|
|
7081
|
+
*
|
|
7082
|
+
* # Capacity
|
|
7083
|
+
*
|
|
7084
|
+
* The buffer never grows past its capacity: [`MemorySink::new`] allows 2 GiB, and
|
|
7085
|
+
* [`MemorySink::with_capacity`] names another. A write or `set_length` that would exceed it fails
|
|
7086
|
+
* `ResourceExhausted` without allocating.
|
|
7104
7087
|
*/
|
|
7105
7088
|
var MemorySink = class extends UniffiAbstractObject {
|
|
7106
7089
|
[uniffiTypeNameSymbol] = "MemorySink";
|
|
@@ -7120,6 +7103,19 @@ var MemorySink = class extends UniffiAbstractObject {
|
|
|
7120
7103
|
this[destructorGuardSymbol] = uniffiTypeMemorySinkObjectFactory.bless(pointer);
|
|
7121
7104
|
}
|
|
7122
7105
|
/**
|
|
7106
|
+
* A sink that refuses to grow past `capacity` bytes.
|
|
7107
|
+
*
|
|
7108
|
+
* # Errors
|
|
7109
|
+
*
|
|
7110
|
+
* The buffer is already larger than `capacity`, or at or above the 2 GiB a byte array can
|
|
7111
|
+
* be counted in.
|
|
7112
|
+
*/
|
|
7113
|
+
static withCapacity(data, capacity) {
|
|
7114
|
+
return FfiConverterTypeMemorySink.lift(uniffiCaller.rustCallWithError(FfiConverterTypeSdkError.lift.bind(FfiConverterTypeSdkError), (callStatus) => {
|
|
7115
|
+
return getter().uniffi_trylimbo_sdk_issuer_fn_constructor_memorysink_with_capacity(FfiConverterArrayBuffer.lower(data, getter().rustbuffer_alloc), FfiConverterUInt64.lower(capacity, getter().rustbuffer_alloc), callStatus);
|
|
7116
|
+
}, FfiConverterString.lift.bind(FfiConverterString)));
|
|
7117
|
+
}
|
|
7118
|
+
/**
|
|
7123
7119
|
* The buffer's current contents, e.g. after passing this sink through `embed`. A copy.
|
|
7124
7120
|
*
|
|
7125
7121
|
* # Errors
|
|
@@ -7241,11 +7237,8 @@ const uniffiTypeMemorySinkObjectFactory = (() => {
|
|
|
7241
7237
|
})();
|
|
7242
7238
|
const FfiConverterTypeMemorySink = new FfiConverterObject(uniffiTypeMemorySinkObjectFactory);
|
|
7243
7239
|
/**
|
|
7244
|
-
* An in-memory [`RangeSource`]
|
|
7245
|
-
*
|
|
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)`.
|
|
7240
|
+
* An in-memory [`RangeSource`] for a caller that already holds the whole asset as bytes:
|
|
7241
|
+
* `MemorySource(data)`, no subclass.
|
|
7249
7242
|
*
|
|
7250
7243
|
* # Size ceiling
|
|
7251
7244
|
*
|
|
@@ -7255,9 +7248,10 @@ const FfiConverterTypeMemorySink = new FfiConverterObject(uniffiTypeMemorySinkOb
|
|
|
7255
7248
|
* [`RangeSource`] over a file handle for anything approaching that: the SDK only ever asks for
|
|
7256
7249
|
* bounded ranges, so nothing else has to hold the asset.
|
|
7257
7250
|
*
|
|
7258
|
-
* Construction
|
|
7259
|
-
*
|
|
7260
|
-
* thread, and neither a ranged source nor
|
|
7251
|
+
* Construction moves the whole asset across the boundary once, on the calling thread; the SDK
|
|
7252
|
+
* then holds what arrived and answers every read as a window into it. That crossing is the one
|
|
7253
|
+
* part of a sign or verify the SDK cannot move off your thread, and neither a ranged source nor
|
|
7254
|
+
* [`FileSource`] pays it.
|
|
7261
7255
|
*/
|
|
7262
7256
|
var MemorySource = class extends UniffiAbstractObject {
|
|
7263
7257
|
[uniffiTypeNameSymbol] = "MemorySource";
|
|
@@ -7379,7 +7373,7 @@ var SignerClient = class extends UniffiAbstractObject {
|
|
|
7379
7373
|
* `options` is malformed. The channel connects lazily, so an unreachable Signer
|
|
7380
7374
|
* surfaces on the first sign RPC instead.
|
|
7381
7375
|
*/
|
|
7382
|
-
static async connect(endpoint, options, asyncOpts_) {
|
|
7376
|
+
static async connect(endpoint, options = ConnectOptions.create({}), asyncOpts_) {
|
|
7383
7377
|
const __stack = uniffiIsDebug ? (/* @__PURE__ */ new Error()).stack : void 0;
|
|
7384
7378
|
try {
|
|
7385
7379
|
return await uniffiRustCallAsync(uniffiCaller, () => {
|
|
@@ -7444,7 +7438,7 @@ const uniffiTypeSignerClientObjectFactory = (() => {
|
|
|
7444
7438
|
})();
|
|
7445
7439
|
const FfiConverterTypeSignerClient = new FfiConverterObject(uniffiTypeSignerClientObjectFactory);
|
|
7446
7440
|
/**
|
|
7447
|
-
* A
|
|
7441
|
+
* A stream signer bound to a [`SignerClient`](super::client::SignerClient) and a
|
|
7448
7442
|
* [`SigningVault`]. Construct once with [`create`](Self::create), then `init` a session and
|
|
7449
7443
|
* sign every segment through the [`StreamSession`] it returns.
|
|
7450
7444
|
*/
|
|
@@ -7466,22 +7460,21 @@ var StreamIssuer = class extends UniffiAbstractObject {
|
|
|
7466
7460
|
}, FfiConverterString.lift.bind(FfiConverterString)));
|
|
7467
7461
|
}
|
|
7468
7462
|
/**
|
|
7469
|
-
* Open the stream
|
|
7470
|
-
*
|
|
7471
|
-
*
|
|
7463
|
+
* Open the stream `id`: mint its first session key under `options.rotation_policy`, sign the
|
|
7464
|
+
* init (moov) segment `source` under `options.delivery`, and hand back a [`StreamSession`]
|
|
7465
|
+
* to sign through.
|
|
7472
7466
|
*
|
|
7473
7467
|
* On `rotation_due`, call [`StreamIssuer::rotate`], not this.
|
|
7474
7468
|
*
|
|
7475
7469
|
* # Errors
|
|
7476
7470
|
*
|
|
7477
|
-
* Fails on signer RPC failure, a vault error, or
|
|
7478
|
-
* segment.
|
|
7471
|
+
* Fails on signer RPC failure, a vault error, or a `source` that isn't a BMFF init segment.
|
|
7479
7472
|
*/
|
|
7480
|
-
async init(
|
|
7473
|
+
async init(id, source, manifest, options, asyncOpts_) {
|
|
7481
7474
|
const __stack = uniffiIsDebug ? (/* @__PURE__ */ new Error()).stack : void 0;
|
|
7482
7475
|
try {
|
|
7483
7476
|
return await uniffiRustCallAsync(uniffiCaller, () => {
|
|
7484
|
-
return getter().uniffi_trylimbo_sdk_issuer_fn_method_streamissuer_init(uniffiTypeStreamIssuerObjectFactory.clonePointer(this), FfiConverterString.lower(
|
|
7477
|
+
return getter().uniffi_trylimbo_sdk_issuer_fn_method_streamissuer_init(uniffiTypeStreamIssuerObjectFactory.clonePointer(this), FfiConverterString.lower(id, getter().rustbuffer_alloc), FfiConverterTypeRangeSource.lower(source, getter().rustbuffer_alloc), FfiConverterTypeStreamManifestSpec.lower(manifest, getter().rustbuffer_alloc), FfiConverterTypeInitOptions.lower(options, getter().rustbuffer_alloc));
|
|
7485
7478
|
}, 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) => {
|
|
7486
7479
|
try {
|
|
7487
7480
|
return FfiConverterTypeStreamStart.lift(__rb);
|
|
@@ -7496,7 +7489,8 @@ var StreamIssuer = class extends UniffiAbstractObject {
|
|
|
7496
7489
|
}
|
|
7497
7490
|
/**
|
|
7498
7491
|
* Succeed `session` on the stream it already names, signing a fresh init (moov) segment
|
|
7499
|
-
* under a new key and forgetting the outgoing one.
|
|
7492
|
+
* under a new key and forgetting the outgoing one. Once this succeeds, `session` refuses to
|
|
7493
|
+
* sign; until then it keeps signing, so a failed rotation can be retried.
|
|
7500
7494
|
*
|
|
7501
7495
|
* The stream id comes from `session`, so a rotation cannot be pointed at the wrong stream,
|
|
7502
7496
|
* and the retired key cannot be left behind: it would still sign for the rest of its
|
|
@@ -7504,13 +7498,14 @@ var StreamIssuer = class extends UniffiAbstractObject {
|
|
|
7504
7498
|
*
|
|
7505
7499
|
* # Errors
|
|
7506
7500
|
*
|
|
7507
|
-
* As [`StreamIssuer::init`]
|
|
7501
|
+
* As [`StreamIssuer::init`], plus `FAILED_PRECONDITION` (`SESSION_ENDED`) for a session
|
|
7502
|
+
* already stopped or rotated, or with a `stop` or `rotate` in flight.
|
|
7508
7503
|
*/
|
|
7509
|
-
async rotate(session,
|
|
7504
|
+
async rotate(session, source, manifest, options, asyncOpts_) {
|
|
7510
7505
|
const __stack = uniffiIsDebug ? (/* @__PURE__ */ new Error()).stack : void 0;
|
|
7511
7506
|
try {
|
|
7512
7507
|
return await uniffiRustCallAsync(uniffiCaller, () => {
|
|
7513
|
-
return getter().uniffi_trylimbo_sdk_issuer_fn_method_streamissuer_rotate(uniffiTypeStreamIssuerObjectFactory.clonePointer(this), FfiConverterTypeStreamSession.lower(session, getter().rustbuffer_alloc), FfiConverterTypeRangeSource.lower(
|
|
7508
|
+
return getter().uniffi_trylimbo_sdk_issuer_fn_method_streamissuer_rotate(uniffiTypeStreamIssuerObjectFactory.clonePointer(this), FfiConverterTypeStreamSession.lower(session, getter().rustbuffer_alloc), FfiConverterTypeRangeSource.lower(source, getter().rustbuffer_alloc), FfiConverterTypeStreamManifestSpec.lower(manifest, getter().rustbuffer_alloc), FfiConverterTypeInitOptions.lower(options, getter().rustbuffer_alloc));
|
|
7514
7509
|
}, 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) => {
|
|
7515
7510
|
try {
|
|
7516
7511
|
return FfiConverterTypeStreamStart.lift(__rb);
|
|
@@ -7578,13 +7573,13 @@ const uniffiTypeStreamIssuerObjectFactory = (() => {
|
|
|
7578
7573
|
const FfiConverterTypeStreamIssuer = new FfiConverterObject(uniffiTypeStreamIssuerObjectFactory);
|
|
7579
7574
|
const uniffiCallbackInterfaceSigningVault = {
|
|
7580
7575
|
vtable: {
|
|
7581
|
-
mint: (uniffiHandle,
|
|
7576
|
+
mint: (uniffiHandle, request, uniffiFutureCallback, uniffiCallbackData) => {
|
|
7582
7577
|
const uniffiMakeCall = async (signal) => {
|
|
7583
|
-
return await FfiConverterTypeSigningVault.lift(uniffiHandle).mint(
|
|
7578
|
+
return await FfiConverterTypeSigningVault.lift(uniffiHandle).mint(FfiConverterTypeMintRequest.lift(request), { signal });
|
|
7584
7579
|
};
|
|
7585
7580
|
const uniffiHandleSuccess = (returnValue) => {
|
|
7586
7581
|
uniffiFutureCallback.call(uniffiFutureCallback, uniffiCallbackData, {
|
|
7587
|
-
return_value:
|
|
7582
|
+
return_value: FfiConverterTypeSessionKey.lower(returnValue, getter().rustbuffer_alloc),
|
|
7588
7583
|
call_status: uniffiCaller.createCallStatus()
|
|
7589
7584
|
});
|
|
7590
7585
|
};
|
|
@@ -7638,23 +7633,25 @@ const uniffiCallbackInterfaceSigningVault = {
|
|
|
7638
7633
|
}
|
|
7639
7634
|
};
|
|
7640
7635
|
const FfiConverterTypeSigningVault = new FfiConverterCallback();
|
|
7641
|
-
const
|
|
7636
|
+
const FfiConverterOptionalTimestamp = new FfiConverterOptional(FfiConverterTimestamp);
|
|
7637
|
+
const FfiConverterOptionalTypeSoftwareAgent = new FfiConverterOptional(FfiConverterTypeSoftwareAgent);
|
|
7642
7638
|
const FfiConverterOptionalString = new FfiConverterOptional(FfiConverterString);
|
|
7643
7639
|
const FfiConverterOptionalTypeUrl = new FfiConverterOptional(FfiConverterTypeUrl);
|
|
7644
|
-
const FfiConverterOptionalTypeActionDetail = new FfiConverterOptional(FfiConverterTypeActionDetail);
|
|
7645
7640
|
const FfiConverterMapStringString = new FfiConverterMap(FfiConverterString, FfiConverterString);
|
|
7646
7641
|
const FfiConverterSequenceTypeFieldViolation = new FfiConverterArray(FfiConverterTypeFieldViolation);
|
|
7647
|
-
const FfiConverterOptionalTypeThumbnail = new FfiConverterOptional(FfiConverterTypeThumbnail);
|
|
7648
7642
|
const FfiConverterSequenceString = new FfiConverterArray(FfiConverterString);
|
|
7643
|
+
const FfiConverterOptionalTypeThumbnail = new FfiConverterOptional(FfiConverterTypeThumbnail);
|
|
7644
|
+
const FfiConverterOptionalTypeActionDetail = new FfiConverterOptional(FfiConverterTypeActionDetail);
|
|
7645
|
+
const FfiConverterOptionalTypeTimespan = new FfiConverterOptional(FfiConverterTypeTimespan);
|
|
7646
|
+
const FfiConverterSequenceTypeBlock = new FfiConverterArray(FfiConverterTypeBlock);
|
|
7649
7647
|
const FfiConverterSequenceTypeAction = new FfiConverterArray(FfiConverterTypeAction);
|
|
7650
7648
|
const FfiConverterSequenceTypeJsonValue = new FfiConverterArray(FfiConverterTypeJsonValue);
|
|
7651
7649
|
const FfiConverterOptionalTypeIdentity = new FfiConverterOptional(FfiConverterTypeIdentity);
|
|
7652
7650
|
const FfiConverterSequenceTypeAssertion = new FfiConverterArray(FfiConverterTypeAssertion);
|
|
7653
|
-
const
|
|
7654
|
-
const
|
|
7655
|
-
const
|
|
7656
|
-
const
|
|
7657
|
-
const FfiConverterSequenceTypeRegion = new FfiConverterArray(FfiConverterTypeRegion);
|
|
7651
|
+
const FfiConverterMapStringTypeComponent = new FfiConverterMap(FfiConverterString, FfiConverterTypeComponent);
|
|
7652
|
+
const FfiConverterOptionalDuration = new FfiConverterOptional(FfiConverterDuration);
|
|
7653
|
+
const FfiConverterSequenceTypeSoftBindingSource = new FfiConverterArray(FfiConverterTypeSoftBindingSource);
|
|
7654
|
+
const FfiConverterSequenceTypeByteRange = new FfiConverterArray(FfiConverterTypeByteRange);
|
|
7658
7655
|
const FfiConverterSequenceTypePluginAuthor = new FfiConverterArray(FfiConverterTypePluginAuthor);
|
|
7659
7656
|
/**
|
|
7660
7657
|
* This should be called before anything else.
|
|
@@ -7670,15 +7667,17 @@ function uniffiEnsureInitialized() {
|
|
|
7670
7667
|
const bindingsContractVersion = 30;
|
|
7671
7668
|
const scaffoldingContractVersion = getter().ffi_trylimbo_sdk_issuer_uniffi_contract_version();
|
|
7672
7669
|
if (bindingsContractVersion !== scaffoldingContractVersion) throw new UniffiInternalError.ContractVersionMismatch(scaffoldingContractVersion, bindingsContractVersion);
|
|
7673
|
-
if (getter().uniffi_trylimbo_sdk_issuer_checksum_func_classify_segment() !==
|
|
7674
|
-
if (getter().
|
|
7670
|
+
if (getter().uniffi_trylimbo_sdk_issuer_checksum_func_classify_segment() !== 38493) throw new UniffiInternalError.ApiChecksumMismatch("uniffi_trylimbo_sdk_issuer_checksum_func_classify_segment");
|
|
7671
|
+
if (getter().uniffi_trylimbo_sdk_issuer_checksum_func_compute_soft_binding() !== 37972) throw new UniffiInternalError.ApiChecksumMismatch("uniffi_trylimbo_sdk_issuer_checksum_func_compute_soft_binding");
|
|
7672
|
+
if (getter().uniffi_trylimbo_sdk_issuer_checksum_func_embed() !== 9865) throw new UniffiInternalError.ApiChecksumMismatch("uniffi_trylimbo_sdk_issuer_checksum_func_embed");
|
|
7675
7673
|
if (getter().uniffi_trylimbo_sdk_issuer_checksum_constructor_assetissuer_create() !== 16073) throw new UniffiInternalError.ApiChecksumMismatch("uniffi_trylimbo_sdk_issuer_checksum_constructor_assetissuer_create");
|
|
7676
|
-
if (getter().uniffi_trylimbo_sdk_issuer_checksum_method_assetissuer_sign() !==
|
|
7674
|
+
if (getter().uniffi_trylimbo_sdk_issuer_checksum_method_assetissuer_sign() !== 30904) throw new UniffiInternalError.ApiChecksumMismatch("uniffi_trylimbo_sdk_issuer_checksum_method_assetissuer_sign");
|
|
7677
7675
|
if (getter().uniffi_trylimbo_sdk_issuer_checksum_constructor_assetmarker_create() !== 41968) throw new UniffiInternalError.ApiChecksumMismatch("uniffi_trylimbo_sdk_issuer_checksum_constructor_assetmarker_create");
|
|
7678
|
-
if (getter().uniffi_trylimbo_sdk_issuer_checksum_method_assetmarker_mark() !==
|
|
7679
|
-
if (getter().
|
|
7680
|
-
if (getter().
|
|
7681
|
-
if (getter().
|
|
7676
|
+
if (getter().uniffi_trylimbo_sdk_issuer_checksum_method_assetmarker_mark() !== 13493) throw new UniffiInternalError.ApiChecksumMismatch("uniffi_trylimbo_sdk_issuer_checksum_method_assetmarker_mark");
|
|
7677
|
+
if (getter().uniffi_trylimbo_sdk_issuer_checksum_method_compute_alg() !== 35230) throw new UniffiInternalError.ApiChecksumMismatch("uniffi_trylimbo_sdk_issuer_checksum_method_compute_alg");
|
|
7678
|
+
if (getter().uniffi_trylimbo_sdk_issuer_checksum_method_compute_compute() !== 21112) throw new UniffiInternalError.ApiChecksumMismatch("uniffi_trylimbo_sdk_issuer_checksum_method_compute_compute");
|
|
7679
|
+
if (getter().uniffi_trylimbo_sdk_issuer_checksum_constructor_filesink_create() !== 38031) throw new UniffiInternalError.ApiChecksumMismatch("uniffi_trylimbo_sdk_issuer_checksum_constructor_filesink_create");
|
|
7680
|
+
if (getter().uniffi_trylimbo_sdk_issuer_checksum_constructor_filesink_open() !== 5590) throw new UniffiInternalError.ApiChecksumMismatch("uniffi_trylimbo_sdk_issuer_checksum_constructor_filesink_open");
|
|
7682
7681
|
if (getter().uniffi_trylimbo_sdk_issuer_checksum_method_filesink_length() !== 7317) throw new UniffiInternalError.ApiChecksumMismatch("uniffi_trylimbo_sdk_issuer_checksum_method_filesink_length");
|
|
7683
7682
|
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");
|
|
7684
7683
|
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");
|
|
@@ -7686,11 +7685,8 @@ function uniffiEnsureInitialized() {
|
|
|
7686
7685
|
if (getter().uniffi_trylimbo_sdk_issuer_checksum_constructor_filesource_open() !== 55871) throw new UniffiInternalError.ApiChecksumMismatch("uniffi_trylimbo_sdk_issuer_checksum_constructor_filesource_open");
|
|
7687
7686
|
if (getter().uniffi_trylimbo_sdk_issuer_checksum_method_filesource_length() !== 21779) throw new UniffiInternalError.ApiChecksumMismatch("uniffi_trylimbo_sdk_issuer_checksum_method_filesource_length");
|
|
7688
7687
|
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");
|
|
7693
7688
|
if (getter().uniffi_trylimbo_sdk_issuer_checksum_constructor_memorysink_new() !== 24274) throw new UniffiInternalError.ApiChecksumMismatch("uniffi_trylimbo_sdk_issuer_checksum_constructor_memorysink_new");
|
|
7689
|
+
if (getter().uniffi_trylimbo_sdk_issuer_checksum_constructor_memorysink_with_capacity() !== 9768) throw new UniffiInternalError.ApiChecksumMismatch("uniffi_trylimbo_sdk_issuer_checksum_constructor_memorysink_with_capacity");
|
|
7694
7690
|
if (getter().uniffi_trylimbo_sdk_issuer_checksum_method_memorysink_bytes() !== 17480) throw new UniffiInternalError.ApiChecksumMismatch("uniffi_trylimbo_sdk_issuer_checksum_method_memorysink_bytes");
|
|
7695
7691
|
if (getter().uniffi_trylimbo_sdk_issuer_checksum_method_memorysink_length() !== 47782) throw new UniffiInternalError.ApiChecksumMismatch("uniffi_trylimbo_sdk_issuer_checksum_method_memorysink_length");
|
|
7696
7692
|
if (getter().uniffi_trylimbo_sdk_issuer_checksum_method_memorysink_read_at() !== 40762) throw new UniffiInternalError.ApiChecksumMismatch("uniffi_trylimbo_sdk_issuer_checksum_method_memorysink_read_at");
|
|
@@ -7705,14 +7701,14 @@ function uniffiEnsureInitialized() {
|
|
|
7705
7701
|
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");
|
|
7706
7702
|
if (getter().uniffi_trylimbo_sdk_issuer_checksum_method_rangesource_length() !== 47043) throw new UniffiInternalError.ApiChecksumMismatch("uniffi_trylimbo_sdk_issuer_checksum_method_rangesource_length");
|
|
7707
7703
|
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");
|
|
7708
|
-
if (getter().uniffi_trylimbo_sdk_issuer_checksum_constructor_signerclient_connect() !==
|
|
7704
|
+
if (getter().uniffi_trylimbo_sdk_issuer_checksum_constructor_signerclient_connect() !== 43720) throw new UniffiInternalError.ApiChecksumMismatch("uniffi_trylimbo_sdk_issuer_checksum_constructor_signerclient_connect");
|
|
7709
7705
|
if (getter().uniffi_trylimbo_sdk_issuer_checksum_constructor_streamissuer_create() !== 59358) throw new UniffiInternalError.ApiChecksumMismatch("uniffi_trylimbo_sdk_issuer_checksum_constructor_streamissuer_create");
|
|
7710
|
-
if (getter().uniffi_trylimbo_sdk_issuer_checksum_method_streamissuer_init() !==
|
|
7711
|
-
if (getter().uniffi_trylimbo_sdk_issuer_checksum_method_streamissuer_rotate() !==
|
|
7712
|
-
if (getter().uniffi_trylimbo_sdk_issuer_checksum_method_streamsession_sign() !==
|
|
7713
|
-
if (getter().uniffi_trylimbo_sdk_issuer_checksum_method_streamsession_stop() !==
|
|
7706
|
+
if (getter().uniffi_trylimbo_sdk_issuer_checksum_method_streamissuer_init() !== 53683) throw new UniffiInternalError.ApiChecksumMismatch("uniffi_trylimbo_sdk_issuer_checksum_method_streamissuer_init");
|
|
7707
|
+
if (getter().uniffi_trylimbo_sdk_issuer_checksum_method_streamissuer_rotate() !== 34487) throw new UniffiInternalError.ApiChecksumMismatch("uniffi_trylimbo_sdk_issuer_checksum_method_streamissuer_rotate");
|
|
7708
|
+
if (getter().uniffi_trylimbo_sdk_issuer_checksum_method_streamsession_sign() !== 5858) throw new UniffiInternalError.ApiChecksumMismatch("uniffi_trylimbo_sdk_issuer_checksum_method_streamsession_sign");
|
|
7709
|
+
if (getter().uniffi_trylimbo_sdk_issuer_checksum_method_streamsession_stop() !== 50071) throw new UniffiInternalError.ApiChecksumMismatch("uniffi_trylimbo_sdk_issuer_checksum_method_streamsession_stop");
|
|
7714
7710
|
uniffiCallbackInterfaceRangeSource.register();
|
|
7715
|
-
|
|
7711
|
+
uniffiCallbackInterfaceCompute.register();
|
|
7716
7712
|
uniffiCallbackInterfaceRangeSink.register();
|
|
7717
7713
|
uniffiCallbackInterfacePluginAuthor.register();
|
|
7718
7714
|
uniffiCallbackInterfaceSigningVault.register();
|
|
@@ -7725,60 +7721,62 @@ var trylimbo_issuer_default = Object.freeze({
|
|
|
7725
7721
|
FfiConverterTypeActionKind,
|
|
7726
7722
|
FfiConverterTypeAssertion,
|
|
7727
7723
|
FfiConverterTypeAssetDelivery,
|
|
7728
|
-
FfiConverterTypeAssetFormat,
|
|
7729
7724
|
FfiConverterTypeAssetIssuer,
|
|
7730
7725
|
FfiConverterTypeAssetManifestSpec,
|
|
7731
7726
|
FfiConverterTypeAssetMarker,
|
|
7732
7727
|
FfiConverterTypeAssetOrigin,
|
|
7733
|
-
|
|
7728
|
+
FfiConverterTypeBlock,
|
|
7729
|
+
FfiConverterTypeByteRange,
|
|
7734
7730
|
FfiConverterTypeCode,
|
|
7735
7731
|
FfiConverterTypeComponent,
|
|
7736
7732
|
FfiConverterTypeComponentEvent,
|
|
7733
|
+
FfiConverterTypeCompute,
|
|
7734
|
+
FfiConverterTypeComputeRequest,
|
|
7737
7735
|
FfiConverterTypeConnectOptions,
|
|
7738
7736
|
FfiConverterTypeCreatedOrigin,
|
|
7739
7737
|
FfiConverterTypeCustomAction,
|
|
7740
|
-
FfiConverterTypeDeriveOptions,
|
|
7741
7738
|
FfiConverterTypeEmbedOptions,
|
|
7742
7739
|
FfiConverterTypeFieldViolation,
|
|
7743
7740
|
FfiConverterTypeFileSink,
|
|
7744
7741
|
FfiConverterTypeFileSource,
|
|
7745
|
-
FfiConverterTypeHeldBinder,
|
|
7746
7742
|
FfiConverterTypeIdentity,
|
|
7747
7743
|
FfiConverterTypeIngredient,
|
|
7748
|
-
|
|
7744
|
+
FfiConverterTypeIngredientKind,
|
|
7749
7745
|
FfiConverterTypeInitOptions,
|
|
7750
7746
|
FfiConverterTypeInitOutcome,
|
|
7751
|
-
FfiConverterTypeIsccBinder,
|
|
7752
7747
|
FfiConverterTypeJsonObject,
|
|
7753
7748
|
FfiConverterTypeJsonValue,
|
|
7754
7749
|
FfiConverterTypeMarkOptions,
|
|
7755
7750
|
FfiConverterTypeMarkOutcome,
|
|
7756
7751
|
FfiConverterTypeMemorySink,
|
|
7757
7752
|
FfiConverterTypeMemorySource,
|
|
7753
|
+
FfiConverterTypeMintRequest,
|
|
7758
7754
|
FfiConverterTypeOpenedOrigin,
|
|
7759
|
-
FfiConverterTypeOrigin,
|
|
7760
7755
|
FfiConverterTypeRangeSink,
|
|
7761
7756
|
FfiConverterTypeRangeSource,
|
|
7762
|
-
FfiConverterTypeRegion,
|
|
7763
7757
|
FfiConverterTypeRotationPolicy,
|
|
7758
|
+
FfiConverterTypeScope,
|
|
7764
7759
|
FfiConverterTypeSdkError,
|
|
7765
7760
|
FfiConverterTypeSegmentKind,
|
|
7766
7761
|
FfiConverterTypeSegmentOutcome,
|
|
7762
|
+
FfiConverterTypeSessionKey,
|
|
7767
7763
|
FfiConverterTypeSignOptions,
|
|
7768
7764
|
FfiConverterTypeSignOutcome,
|
|
7769
7765
|
FfiConverterTypeSignOutput,
|
|
7770
7766
|
FfiConverterTypeSignerClient,
|
|
7771
7767
|
FfiConverterTypeSoftBinding,
|
|
7768
|
+
FfiConverterTypeSoftBindingSource,
|
|
7769
|
+
FfiConverterTypeSoftwareAgent,
|
|
7772
7770
|
FfiConverterTypeStandardAction,
|
|
7773
7771
|
FfiConverterTypeStreamDelivery,
|
|
7774
7772
|
FfiConverterTypeStreamIssuer,
|
|
7775
7773
|
FfiConverterTypeStreamManifestSpec,
|
|
7774
|
+
FfiConverterTypeStreamOrigin,
|
|
7776
7775
|
FfiConverterTypeStreamSession,
|
|
7777
7776
|
FfiConverterTypeStreamStart,
|
|
7778
7777
|
FfiConverterTypeThumbnail,
|
|
7779
|
-
|
|
7780
|
-
FfiConverterTypeUrl
|
|
7781
|
-
FfiConverterTypeVaultPublicKey
|
|
7778
|
+
FfiConverterTypeTimespan,
|
|
7779
|
+
FfiConverterTypeUrl
|
|
7782
7780
|
}
|
|
7783
7781
|
});
|
|
7784
7782
|
//#endregion
|
|
@@ -7791,4 +7789,4 @@ if (!initialized) {
|
|
|
7791
7789
|
async function uniffiInitAsync() {}
|
|
7792
7790
|
var ffi_trylimbo_sdk_issuer_default = { trylimbo_issuer: trylimbo_issuer_exports };
|
|
7793
7791
|
//#endregion
|
|
7794
|
-
export { Action, ActionDetail, ActionKind, ActionKind_Tags, Action_Tags, Assertion, AssetDelivery, AssetDelivery_Tags,
|
|
7792
|
+
export { Action, ActionDetail, ActionKind, ActionKind_Tags, Action_Tags, Assertion, AssetDelivery, AssetDelivery_Tags, AssetIssuer, AssetManifestSpec, AssetMarker, AssetOrigin, AssetOrigin_Tags, Block, ByteRange, Code, Component, ComponentEvent, ComponentEvent_Tags, ComputeImpl, ComputeRequest, ConnectOptions, CreatedOrigin, CustomAction, EmbedOptions, FieldViolation, FileSink, FileSource, Identity, Ingredient, IngredientKind, IngredientKind_Tags, InitOptions, InitOutcome, MarkOptions, MarkOutcome, MemorySink, MemorySource, MintRequest, OpenedOrigin, RangeSinkImpl, RangeSourceImpl, RotationPolicy, Scope, SdkError, SdkError_Tags, SegmentKind, SegmentOutcome, SessionKey, SignOptions, SignOutcome, SignOutput, SignOutput_Tags, SignerClient, SoftBinding, SoftBindingSource, SoftBindingSource_Tags, SoftwareAgent, StandardAction, StreamDelivery, StreamIssuer, StreamManifestSpec, StreamOrigin, StreamOrigin_Tags, StreamSession, StreamStart, Thumbnail, Timespan, classifySegment, computeSoftBinding, ffi_trylimbo_sdk_issuer_default as default, embed, uniffiInitAsync };
|