{{ self::swift_doc_block(cls.doc, "") }}public final class {{ cls.name }} {
    let handle: OpaquePointer

    init(handle: OpaquePointer) {
        self.handle = handle
    }
{%- for ctor in cls.constructors %}
{%- if ctor.is_designated() %}

{{ self::swift_doc_block(ctor.doc(), "    ") }}    public init{% if ctor.is_optional() %}?{% endif %}({% for p in ctor.params() %}{{ p.signature() }}{% if !loop.last %}, {% endif %}{% endfor %}){% if ctor.is_fallible() %} throws{% endif %} {
{%- for param in ctor.params() %}
{%- if let Some(wrapper) = param.wrapper_code() %}
        {{ wrapper }}
{%- endif %}
{%- endfor %}
{%- if ctor.is_optional() %}
        guard let ptr = {% for w in ctor.annotated_closure_wrappers() %}{{ w }} {% endfor %}{{ ctor.call_expr() }}{% for _ in ctor.closure_wrappers() %} }{% endfor %} else {
            return nil
        }
{%- elif ctor.is_fallible() %}
        guard let ptr = {% for w in ctor.annotated_closure_wrappers() %}{{ w }} {% endfor %}{{ ctor.call_expr() }}{% for _ in ctor.closure_wrappers() %} }{% endfor %} else {
            throw FfiError(message: takeLastErrorMessage())
        }
{%- else %}
        let ptr = {% for w in ctor.annotated_closure_wrappers() %}{{ w }} {% endfor %}{{ ctor.call_expr() }}{% for _ in ctor.closure_wrappers() %} }{% endfor %}!
{%- endif %}
        self.handle = ptr
    }
{%- else if ctor.is_factory() %}

{{ self::swift_doc_block(ctor.doc(), "    ") }}    public static func {{ ctor.name().unwrap() }}(){% if ctor.is_fallible() %} throws{% endif %} -> {{ cls.name }}{% if ctor.is_optional() %}?{% endif %} {
{%- if ctor.is_optional() %}
        guard let ptr = {{ ctor.ffi_symbol() }}() else {
            return nil
        }
{%- elif ctor.is_fallible() %}
        guard let ptr = {{ ctor.ffi_symbol() }}() else {
            throw FfiError(message: takeLastErrorMessage())
        }
{%- else %}
        let ptr = {{ ctor.ffi_symbol() }}()!
{%- endif %}
        return {{ cls.name }}(handle: ptr)
    }
{%- else if ctor.is_convenience() %}

{{ self::swift_doc_block(ctor.doc(), "    ") }}    public convenience init{% if ctor.is_optional() %}?{% endif %}({% for p in ctor.params() %}{{ p.signature() }}{% if !loop.last %}, {% endif %}{% endfor %}){% if ctor.is_fallible() %} throws{% endif %} {
{%- for param in ctor.params() %}
{%- if let Some(wrapper) = param.wrapper_code() %}
        {{ wrapper }}
{%- endif %}
{%- endfor %}
{%- if ctor.is_optional() %}
        guard let ptr = {% for w in ctor.annotated_closure_wrappers() %}{{ w }} {% endfor %}{{ ctor.call_expr() }}{% for _ in ctor.closure_wrappers() %} }{% endfor %} else {
            return nil
        }
{%- elif ctor.is_fallible() %}
        guard let ptr = {% for w in ctor.annotated_closure_wrappers() %}{{ w }} {% endfor %}{{ ctor.call_expr() }}{% for _ in ctor.closure_wrappers() %} }{% endfor %} else {
            throw FfiError(message: takeLastErrorMessage())
        }
{%- else %}
        let ptr = {% for w in ctor.annotated_closure_wrappers() %}{{ w }} {% endfor %}{{ ctor.call_expr() }}{% for _ in ctor.closure_wrappers() %} }{% endfor %}!
{%- endif %}
        self.init(handle: ptr)
    }
{%- endif %}
{%- endfor %}

    deinit {
        {{ cls.ffi_free }}(handle)
    }
{%- for method in cls.methods %}

{{ self::swift_doc_block(method.doc, "    ") }}    public{% if method.is_mutating() %} mutating{% elif method.is_static %} static{% endif %} func {{ method.name }}({% for p in method.params %}{{ p.signature() }}{% if !loop.last %}, {% endif %}{% endfor %}){% if method.mode.is_async() %} async throws{% if let Some(result) = method.mode.async_result() %}{% if let Some(ret) = result.swift_type() %} -> {{ ret }}{% endif %}{% endif %}{% else %}{% if method.returns.is_throws() %} throws{% endif %}{% if let Some(ret) = method.returns.swift_type() %} -> {{ ret }}{% endif %}{% endif %} {
{%- match method.mode %}
{%- when SwiftCallMode::Async { start, poll, complete, cancel, free, result } %}
{%- for param in method.params %}
{%- if let Some(wrapper) = param.wrapper_code() %}
        {{ wrapper }}
{%- endif %}
{%- endfor %}
        let futureHandle = {% for w in method.closure_wrappers() %}{{ w }} {% endfor %}{{ method.start_call_expr() }}{% for _ in method.closure_wrappers() %} }{% endfor %}

{%- if result.is_direct() || result.is_unit() %}
{%- if result.is_direct() %}
        let rawResult = try await boltffiAsyncCallDirect(
            futureHandle: futureHandle,
            pollFn: {{ poll }},
            completeFn: {{ complete }},
            cancelFn: {{ cancel }},
            freeFn: {{ free }}
        )
{%- if let Some(expr) = result.direct_return_expr("rawResult") %}
        return {{ expr }}
{%- endif %}
{%- else %}
        return try await boltffiAsyncCallDirect(
            futureHandle: futureHandle,
            pollFn: {{ poll }},
            completeFn: {{ complete }},
            cancelFn: {{ cancel }},
            freeFn: {{ free }}
        )
{%- endif %}
{%- elif result.is_direct_buffer() %}
        return try await boltffiAsyncCall(
            futureHandle: futureHandle,
            pollFn: {{ poll }},
            completeFn: {{ complete }},
            cancelFn: {{ cancel }},
            freeFn: {{ free }}
        ) { buf, status in
            guard status.code == 0 else { {{ prefix }}_free_buf(buf); throw FfiError(message: "ffi call failed") }
            defer { {{ prefix }}_free_buf(buf) }
{%- if result.direct_buffer_is_data() %}
            guard buf.len > 0, let ptr = buf.ptr else { return Data() }
            return Data(bytes: ptr, count: Int(buf.len))
{%- else %}
            guard buf.len > 0, let ptr = buf.ptr else { return [] }
            let count = Int(buf.len) / MemoryLayout<{{ result.direct_buffer_element_type().unwrap() }}>.stride
            let rawPtr = UnsafeRawPointer(ptr).assumingMemoryBound(to: {{ result.direct_buffer_element_type().unwrap() }}.self)
{%- if let Some(mapping) = result.direct_buffer_composite_mapping() %}
            return (0..<count).map { i in
                let _raw = rawPtr[i]
                return {{ mapping.swift_record_type }}({% for f in mapping.fields %}{{ f.swift_name }}: _raw.{{ f.c_name }}{% if !loop.last %}, {% endif %}{% endfor %})
            }
{%- elif let Some(enum_name) = result.direct_buffer_enum_mapping() %}
            return Array(UnsafeBufferPointer(start: UnsafeRawPointer(rawPtr).assumingMemoryBound(to: {{ enum_name }}.self), count: count))
{%- else %}
            return Array(UnsafeBufferPointer(start: rawPtr, count: count))
{%- endif %}
{%- endif %}
        }
{%- else %}
        return try await boltffiAsyncCall(
            futureHandle: futureHandle,
            pollFn: {{ poll }},
            completeFn: {{ complete }},
            cancelFn: {{ cancel }},
            freeFn: {{ free }}
        ) { buf, status in
            guard status.code == 0 else { {{ prefix }}_free_buf(buf); throw FfiError(message: "ffi call failed") }
{%- if result.throws() %}
            defer { {{ prefix }}_free_buf(buf) }
            return try boltffiDecodeOwnedBuf(buf.ptr, Int(buf.len)) { reader in {{ result.reader_decode_expr().unwrap() }} }
{%- else %}
            defer { {{ prefix }}_free_buf(buf) }
            return boltffiDecodeOwnedBuf(buf.ptr, Int(buf.len)) { reader in {{ result.reader_decode_expr().unwrap() }} }
{%- endif %}
        }
{%- endif %}
{%- when SwiftCallMode::Sync { symbol } %}
{%- for param in method.params %}
{%- if let Some(wrapper) = param.wrapper_code() %}
        {{ wrapper }}
{%- endif %}
{%- endfor %}
{%- if let Some(rs) = method.value_self %}
{%- if let Some(wrapper) = rs.wrapper_code %}
        {{ wrapper }}
{%- endif %}
{%- endif %}
{%- for open in method.sync_closure_opens() %}
{{ open }}
{%- endfor %}
{%- if method.returns.is_void() %}
{{ method.method_body_indent() }}{{ method.sync_call_expr() }}
{%- elif method.returns.is_direct_buffer() %}
{{ method.method_body_indent() }}let buf = {{ method.sync_call_expr() }}
{{ method.method_body_indent() }}defer { {{ prefix }}_free_buf(buf) }
{%- if method.returns.direct_buffer_is_data() %}
{{ method.method_body_indent() }}guard buf.len > 0, let ptr = buf.ptr else { return Data() }
{{ method.method_body_indent() }}return Data(bytes: ptr, count: Int(buf.len))
{%- else %}
{{ method.method_body_indent() }}guard buf.len > 0, let ptr = buf.ptr else { return [] }
{{ method.method_body_indent() }}let count = Int(buf.len) / MemoryLayout<{{ method.returns.direct_buffer_element_type().unwrap() }}>.stride
{{ method.method_body_indent() }}let rawPtr = UnsafeRawPointer(ptr).assumingMemoryBound(to: {{ method.returns.direct_buffer_element_type().unwrap() }}.self)
{%- if let Some(mapping) = method.returns.direct_buffer_composite_mapping() %}
{{ method.method_body_indent() }}return (0..<count).map { i in
{{ method.method_body_indent() }}    let _raw = rawPtr[i]
{{ method.method_body_indent() }}    return {{ mapping.swift_record_type }}({% for f in mapping.fields %}{{ f.swift_name }}: _raw.{{ f.c_name }}{% if !loop.last %}, {% endif %}{% endfor %})
{{ method.method_body_indent() }}}
{%- elif let Some(enum_name) = method.returns.direct_buffer_enum_mapping() %}
{{ method.method_body_indent() }}return Array(UnsafeBufferPointer(start: UnsafeRawPointer(rawPtr).assumingMemoryBound(to: {{ enum_name }}.self), count: count))
{%- else %}
{{ method.method_body_indent() }}return Array(UnsafeBufferPointer(start: rawPtr, count: count))
{%- endif %}
{%- endif %}
{%- elif method.returns.is_wire_encoded() %}
{{ method.method_body_indent() }}let buf = {{ method.sync_call_expr() }}
{{ method.method_body_indent() }}defer { {{ prefix }}_free_buf(buf) }
{%- if let Some(reader_expr) = method.returns.reader_decode_expr() %}
{%- if method.is_mutating() %}
{{ method.method_body_indent() }}self = boltffiDecodeOwnedBuf(buf.ptr, Int(buf.len)) { reader in {{ reader_expr }} }
{%- elif method.returns.is_throws() %}
{{ method.method_body_indent() }}return try boltffiDecodeOwnedBuf(buf.ptr, Int(buf.len)) { reader in {{ reader_expr }} }
{%- else %}
{{ method.method_body_indent() }}return boltffiDecodeOwnedBuf(buf.ptr, Int(buf.len)) { reader in {{ reader_expr }} }
{%- endif %}
{%- elif let Some(decode_expr) = method.returns.decode_expr() %}
{{ method.method_body_indent() }}let wire = WireBuffer(ptr: buf.ptr!, len: Int(buf.len))
{%- if method.is_mutating() %}
{{ method.method_body_indent() }}self = {{ decode_expr }}
{%- else %}
{{ method.method_body_indent() }}return {{ decode_expr }}
{%- endif %}
{%- endif %}
{%- elif method.returns.is_throws() %}
{{ method.method_body_indent() }}fatalError("throwing methods not yet implemented in IR backend")
{%- elif let Some((class_name, nullable)) = method.returns.handle_info() %}
{%- if nullable %}
{{ method.method_body_indent() }}guard let ptr = {{ method.sync_call_expr() }} else { return nil }
{{ method.method_body_indent() }}return {{ class_name }}(handle: ptr)
{%- else %}
{{ method.method_body_indent() }}let ptr = {{ method.sync_call_expr() }}!
{{ method.method_body_indent() }}return {{ class_name }}(handle: ptr)
{%- endif %}
{%- elif let Some((protocol_name, nullable)) = method.returns.callback_info() %}
{{ method.method_body_indent() }}let callback = {{ method.sync_call_expr() }}
{%- if nullable %}
{{ method.method_body_indent() }}guard callback.handle != 0 else { return nil }
{%- endif %}
{{ method.method_body_indent() }}return {{ protocol_name }}Bridge.wrap(callback)
{%- elif method.returns.is_composite() %}
{%- if let Some(convert_expr) = method.returns.composite_convert_expr("_raw") %}
{{ method.method_body_indent() }}let _raw = {{ method.sync_call_expr() }}
{%- if method.is_mutating() %}
{{ method.method_body_indent() }}self = {{ convert_expr }}
{%- else %}
{{ method.method_body_indent() }}return {{ convert_expr }}
{%- endif %}
{%- endif %}
{%- elif method.returns.is_c_style_enum() %}
{{ method.method_body_indent() }}return {{ method.returns.c_style_enum_type().unwrap() }}(rawValue: {{ method.sync_call_expr() }})!
{%- else %}
{{ method.method_body_indent() }}return {{ method.sync_call_expr() }}
{%- endif %}
{%- for close in method.sync_closure_closes() %}
{{ close }}
{%- endfor %}
{%- endmatch %}
    }
{%- endfor %}
{% for stream in cls.streams %}

{%- match stream.mode %}
{%- when SwiftStreamMode::Async %}
    public func {{ stream.name }}() -> _Concurrency.AsyncStream<{{ stream.item_type }}> {
        _Concurrency.AsyncStream<{{ stream.item_type }}>(bufferingPolicy: .unbounded) { continuation in
            guard let subscription = {{ stream.subscribe }}(self.handle) else {
                continuation.finish()
                return
            }
            let context = WireStreamContextBase(
                subscription: subscription, batchSize: 16,
                drainAvailableItems: { subscription, batchSize in
{%- match stream.item_delivery %}
{%- when SwiftStreamItemDelivery::WireEncoded { .. } %}
                    boltffiDrainWireStreamBatch(
                        subscription: subscription,
                        batchSize: batchSize,
                        popBatch: {{ stream.pop_batch }},
                        freeBuf: {{ stream.free_buf }}
                    ) { reader in
                        let count = Int(reader.readU32())
                        for _ in 0..<count {
                            let item = {{ stream.item_delivery.reader_decode_expr().unwrap() }}
                            _ = continuation.yield(item)
                        }
                    }
{%- when SwiftStreamItemDelivery::Direct { c_element_type, .. } %}
                    boltffiDrainDirectStreamBatch(
                        subscription: subscription,
                        batchSize: batchSize,
                        popBatch: {{ stream.pop_batch }}
                    ) { rawItems in
                        for rawItem in rawItems {
                            let item = {{ stream.item_delivery.direct_item_expr("rawItem").unwrap() }}
                            _ = continuation.yield(item)
                        }
                    }
{%- endmatch %}
                },
                poll: {{ stream.poll }},
                unsubscribe: {{ stream.unsubscribe }},
                freeFn: {{ stream.free }},
                atomicCas: {{ stream.atomic_cas }},
                finish: { continuation.finish() }
            )
            continuation.onTermination = { @Sendable _ in context.requestTermination() }
            context.start()
        }
    }
{%- when SwiftStreamMode::Batch { class_name, method_name_pascal } %}
    public func {{ stream.name }}() -> {{ class_name }}{{ method_name_pascal }}Subscription {
        {{ class_name }}{{ method_name_pascal }}Subscription(
            handle: {{ stream.subscribe }}(self.handle),
            readBatch: { subscription, batchSize in
{%- match stream.item_delivery %}
{%- when SwiftStreamItemDelivery::WireEncoded { .. } %}
                boltffiReadWireStreamBatch(
                    subscription: subscription,
                    batchSize: batchSize,
                    popBatch: {{ stream.pop_batch }},
                    freeBuf: {{ stream.free_buf }}
                ) { reader in
                    let count = Int(reader.readU32())
                    var result: [{{ stream.item_type }}] = []
                    result.reserveCapacity(count)
                    for _ in 0..<count {
                        let item = {{ stream.item_delivery.reader_decode_expr().unwrap() }}
                        result.append(item)
                    }
                    return result
                }
{%- when SwiftStreamItemDelivery::Direct { c_element_type, .. } %}
                return boltffiReadDirectStreamBatch(
                    subscription: subscription,
                    batchSize: batchSize,
                    popBatch: {{ stream.pop_batch }}
                ) { rawItems in
                    rawItems.map { rawItem in
                    {{ stream.item_delivery.direct_item_expr("rawItem").unwrap() }}
                    }
                }
{%- endmatch %}
            },
            wait: {{ stream.wait }},
            unsubscribe: {{ stream.unsubscribe }},
            freeFn: {{ stream.free }}
        )
    }
{%- when SwiftStreamMode::Callback { class_name, method_name_pascal } %}
    public func {{ stream.name }}(callback: @escaping ({{ stream.item_type }}) -> Void) -> {{ class_name }}{{ method_name_pascal }}Cancellable {
        guard let subscription = {{ stream.subscribe }}(self.handle) else {
            return {{ class_name }}{{ method_name_pascal }}Cancellable {}
        }

        final class CallbackContext: @unchecked Sendable {
            let subscription: SubscriptionHandle
            let batchSize: UInt
            let drainAvailableItems: (SubscriptionHandle, UInt) -> Bool
            let unsubscribe: (SubscriptionHandle?) -> Void
            let freeFn: (SubscriptionHandle?) -> Void
            let atomicCas: (UnsafeMutablePointer<UInt8>?, UInt8, UInt8) -> Bool
            let callback: ({{ stream.item_type }}) -> Void
            private var lifecycleTag: UInt8 = 0
            private var callbackTag: UInt8 = 0

            init(
                subscription: SubscriptionHandle, batchSize: UInt,
                drainAvailableItems: @escaping (SubscriptionHandle, UInt) -> Bool,
                poll: @escaping (SubscriptionHandle?, UInt64, StreamContinuationCallback?) -> Void,
                unsubscribe: @escaping (SubscriptionHandle?) -> Void,
                freeFn: @escaping (SubscriptionHandle?) -> Void,
                atomicCas: @escaping (UnsafeMutablePointer<UInt8>?, UInt8, UInt8) -> Bool,
                callback: @escaping ({{ stream.item_type }}) -> Void
            ) {
                self.subscription = subscription; self.batchSize = batchSize
                self.drainAvailableItems = drainAvailableItems; self.unsubscribe = unsubscribe
                self.freeFn = freeFn; self.atomicCas = atomicCas
                self.callback = callback
            }

            func start() { registerPoll() }

            func requestTermination() {
                let started = withUnsafeMutablePointer(to: &lifecycleTag) { atomicCas($0, 0, 1) }
                if started { unsubscribe(subscription); _ = withUnsafeMutablePointer(to: &lifecycleTag) { atomicCas($0, 1, 2) } }
                attemptFinalize()
            }

            private func attemptFinalize() {
                guard (withUnsafeMutablePointer(to: &callbackTag) { atomicCas($0, 0, 0) }) else { return }
                guard (withUnsafeMutablePointer(to: &lifecycleTag) { atomicCas($0, 2, 3) }) else { return }
                freeFn(subscription)
            }

            private func schedulePoll() { _Concurrency.Task { [self] in await _Concurrency.Task.yield(); registerPoll() } }

            private func registerPoll() {
                guard (withUnsafeMutablePointer(to: &lifecycleTag) { atomicCas($0, 0, 0) }) else { attemptFinalize(); return }
                let data = UInt64(UInt(bitPattern: Unmanaged.passRetained(self).toOpaque()))
                {{ stream.poll }}(subscription, data) { data, result in
                    Unmanaged<CallbackContext>.fromOpaque(UnsafeRawPointer(bitPattern: UInt(data))!).takeRetainedValue().handlePoll(result)
                }
            }

            private func handlePoll(_ pollResult: Int8) {
                let isClosed = pollResult == StreamPollResult.closed.rawValue
                guard (withUnsafeMutablePointer(to: &callbackTag) { atomicCas($0, 0, 1) }) else { attemptFinalize(); return }
                defer { _ = withUnsafeMutablePointer(to: &callbackTag) { atomicCas($0, 1, 0) }; attemptFinalize() }
                guard (withUnsafeMutablePointer(to: &lifecycleTag) { atomicCas($0, 0, 0) }) else { return }
                while drainAvailableItems(subscription, batchSize) {}
                if isClosed { requestTermination(); return }
                guard (withUnsafeMutablePointer(to: &lifecycleTag) { atomicCas($0, 0, 0) }) else { return }
                schedulePoll()
            }
        }

        let context = CallbackContext(
            subscription: subscription, batchSize: 16,
            drainAvailableItems: { subscription, batchSize in
{%- match stream.item_delivery %}
{%- when SwiftStreamItemDelivery::WireEncoded { .. } %}
                boltffiDrainWireStreamBatch(
                    subscription: subscription,
                    batchSize: batchSize,
                    popBatch: {{ stream.pop_batch }},
                    freeBuf: {{ stream.free_buf }}
                ) { reader in
                    let count = Int(reader.readU32())
                    for _ in 0..<count {
                        let item = {{ stream.item_delivery.reader_decode_expr().unwrap() }}
                        callback(item)
                    }
                }
{%- when SwiftStreamItemDelivery::Direct { c_element_type, .. } %}
                boltffiDrainDirectStreamBatch(
                    subscription: subscription,
                    batchSize: batchSize,
                    popBatch: {{ stream.pop_batch }}
                ) { rawItems in
                    for rawItem in rawItems {
                        let item = {{ stream.item_delivery.direct_item_expr("rawItem").unwrap() }}
                        callback(item)
                    }
                }
{%- endmatch %}
            },
            poll: {{ stream.poll }},
            unsubscribe: {{ stream.unsubscribe }},
            freeFn: {{ stream.free }},
            atomicCas: {{ stream.atomic_cas }},
            callback: callback
        )
        context.start()
        return {{ class_name }}{{ method_name_pascal }}Cancellable { context.requestTermination() }
    }
{%- endmatch %}
{%- endfor %}
}
{%- for stream in cls.streams %}
{%- match stream.mode %}
{%- when SwiftStreamMode::Batch { class_name, method_name_pascal } %}

public final class {{ class_name }}{{ method_name_pascal }}Subscription {
    private let handle: SubscriptionHandle?
    private let readBatchFn: (SubscriptionHandle, UInt) -> [{{ stream.item_type }}]
    private let waitFn: (SubscriptionHandle, UInt32) -> Int32
    private let unsubscribeFn: (SubscriptionHandle?) -> Void
    private let freeFn: (SubscriptionHandle?) -> Void
    private var isUnsubscribed = false

    init(
        handle: SubscriptionHandle?,
        readBatch: @escaping (SubscriptionHandle, UInt) -> [{{ stream.item_type }}],
        wait: @escaping (SubscriptionHandle, UInt32) -> Int32,
        unsubscribe: @escaping (SubscriptionHandle?) -> Void,
        freeFn: @escaping (SubscriptionHandle?) -> Void
    ) {
        self.handle = handle
        self.readBatchFn = readBatch
        self.waitFn = wait
        self.unsubscribeFn = unsubscribe
        self.freeFn = freeFn
    }

    deinit {
        freeFn(handle)
    }

    public func popBatch(maxCount: UInt = 16) -> [{{ stream.item_type }}] {
        guard let h = handle else { return [] }
        return readBatchFn(h, maxCount)
    }

    public func wait(timeout: UInt32) -> Int32 {
        guard let h = handle else { return -1 }
        return waitFn(h, timeout)
    }

    public func unsubscribe() {
        guard !isUnsubscribed else { return }
        isUnsubscribed = true
        unsubscribeFn(handle)
    }
}
{%- when SwiftStreamMode::Callback { class_name, method_name_pascal } %}

public final class {{ class_name }}{{ method_name_pascal }}Cancellable {
    private var isCancelled = false
    private let cancelAction: () -> Void

    init(onCancel: @escaping () -> Void = {}) {
        self.cancelAction = onCancel
    }

    deinit {
        cancel()
    }

    public func cancel() {
        guard !isCancelled else { return }
        isCancelled = true
        cancelAction()
    }
}
{%- when SwiftStreamMode::Async %}
{%- endmatch %}
{%- endfor %}
